]>
Commit | Line | Data |
---|---|---|
ae7467b1 AB |
1 | /* |
2 | * gdb server stub - softmmu specific bits | |
3 | * | |
4 | * Debug integration depends on support from the individual | |
5 | * accelerators so most of this involves calling the ops helpers. | |
6 | * | |
9455762f | 7 | * Copyright (c) 2003-2005 Fabrice Bellard |
ae7467b1 AB |
8 | * Copyright (c) 2022 Linaro Ltd |
9 | * | |
9455762f | 10 | * SPDX-License-Identifier: LGPL-2.0+ |
ae7467b1 AB |
11 | */ |
12 | ||
13 | #include "qemu/osdep.h" | |
b6fa2ec2 AB |
14 | #include "qapi/error.h" |
15 | #include "qemu/error-report.h" | |
16 | #include "qemu/cutils.h" | |
ae7467b1 | 17 | #include "exec/gdbstub.h" |
c566080c | 18 | #include "gdbstub/syscalls.h" |
b6fa2ec2 AB |
19 | #include "exec/hwaddr.h" |
20 | #include "exec/tb-flush.h" | |
ae7467b1 | 21 | #include "sysemu/cpus.h" |
b6fa2ec2 AB |
22 | #include "sysemu/runstate.h" |
23 | #include "sysemu/replay.h" | |
24 | #include "hw/core/cpu.h" | |
25 | #include "hw/cpu/cluster.h" | |
26 | #include "hw/boards.h" | |
27 | #include "chardev/char.h" | |
28 | #include "chardev/char-fe.h" | |
29 | #include "monitor/monitor.h" | |
30 | #include "trace.h" | |
ae7467b1 AB |
31 | #include "internals.h" |
32 | ||
b6fa2ec2 AB |
33 | /* System emulation specific state */ |
34 | typedef struct { | |
35 | CharBackend chr; | |
36 | Chardev *mon_chr; | |
37 | } GDBSystemState; | |
38 | ||
39 | GDBSystemState gdbserver_system_state; | |
40 | ||
41 | static void reset_gdbserver_state(void) | |
42 | { | |
43 | g_free(gdbserver_state.processes); | |
44 | gdbserver_state.processes = NULL; | |
45 | gdbserver_state.process_num = 0; | |
75837005 | 46 | gdbserver_state.allow_stop_reply = false; |
b6fa2ec2 AB |
47 | } |
48 | ||
49 | /* | |
50 | * Return the GDB index for a given vCPU state. | |
51 | * | |
52 | * In system mode GDB numbers CPUs from 1 as 0 is reserved as an "any | |
53 | * cpu" index. | |
54 | */ | |
55 | int gdb_get_cpu_index(CPUState *cpu) | |
56 | { | |
57 | return cpu->cpu_index + 1; | |
58 | } | |
59 | ||
a7e0f9bd AB |
60 | /* |
61 | * We check the status of the last message in the chardev receive code | |
62 | */ | |
63 | bool gdb_got_immediate_ack(void) | |
64 | { | |
65 | return true; | |
66 | } | |
67 | ||
b6fa2ec2 AB |
68 | /* |
69 | * GDB Connection management. For system emulation we do all of this | |
70 | * via our existing Chardev infrastructure which allows us to support | |
71 | * network and unix sockets. | |
72 | */ | |
73 | ||
74 | void gdb_put_buffer(const uint8_t *buf, int len) | |
75 | { | |
76 | /* | |
77 | * XXX this blocks entire thread. Rewrite to use | |
78 | * qemu_chr_fe_write and background I/O callbacks | |
79 | */ | |
80 | qemu_chr_fe_write_all(&gdbserver_system_state.chr, buf, len); | |
81 | } | |
82 | ||
83 | static void gdb_chr_event(void *opaque, QEMUChrEvent event) | |
84 | { | |
85 | int i; | |
86 | GDBState *s = (GDBState *) opaque; | |
87 | ||
88 | switch (event) { | |
89 | case CHR_EVENT_OPENED: | |
90 | /* Start with first process attached, others detached */ | |
91 | for (i = 0; i < s->process_num; i++) { | |
92 | s->processes[i].attached = !i; | |
93 | } | |
94 | ||
95 | s->c_cpu = gdb_first_attached_cpu(); | |
96 | s->g_cpu = s->c_cpu; | |
97 | ||
98 | vm_stop(RUN_STATE_PAUSED); | |
99 | replay_gdb_attached(); | |
100 | gdb_has_xml = false; | |
101 | break; | |
102 | default: | |
103 | break; | |
104 | } | |
105 | } | |
106 | ||
131f387d AB |
107 | /* |
108 | * In softmmu mode we stop the VM and wait to send the syscall packet | |
109 | * until notification that the CPU has stopped. This must be done | |
110 | * because if the packet is sent now the reply from the syscall | |
111 | * request could be received while the CPU is still in the running | |
112 | * state, which can cause packets to be dropped and state transition | |
113 | * 'T' packets to be sent while the syscall is still being processed. | |
114 | */ | |
115 | void gdb_syscall_handling(const char *syscall_packet) | |
116 | { | |
117 | vm_stop(RUN_STATE_DEBUG); | |
118 | qemu_cpu_kick(gdbserver_state.c_cpu); | |
119 | } | |
120 | ||
b6fa2ec2 AB |
121 | static void gdb_vm_state_change(void *opaque, bool running, RunState state) |
122 | { | |
123 | CPUState *cpu = gdbserver_state.c_cpu; | |
124 | g_autoptr(GString) buf = g_string_new(NULL); | |
125 | g_autoptr(GString) tid = g_string_new(NULL); | |
126 | const char *type; | |
127 | int ret; | |
128 | ||
129 | if (running || gdbserver_state.state == RS_INACTIVE) { | |
130 | return; | |
131 | } | |
c566080c | 132 | |
b6fa2ec2 | 133 | /* Is there a GDB syscall waiting to be sent? */ |
c566080c | 134 | if (gdb_handled_syscall()) { |
b6fa2ec2 AB |
135 | return; |
136 | } | |
137 | ||
138 | if (cpu == NULL) { | |
139 | /* No process attached */ | |
140 | return; | |
141 | } | |
142 | ||
75837005 MTB |
143 | if (!gdbserver_state.allow_stop_reply) { |
144 | return; | |
145 | } | |
146 | ||
b6fa2ec2 AB |
147 | gdb_append_thread_id(cpu, tid); |
148 | ||
149 | switch (state) { | |
150 | case RUN_STATE_DEBUG: | |
151 | if (cpu->watchpoint_hit) { | |
152 | switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) { | |
153 | case BP_MEM_READ: | |
154 | type = "r"; | |
155 | break; | |
156 | case BP_MEM_ACCESS: | |
157 | type = "a"; | |
158 | break; | |
159 | default: | |
160 | type = ""; | |
161 | break; | |
162 | } | |
163 | trace_gdbstub_hit_watchpoint(type, | |
164 | gdb_get_cpu_index(cpu), | |
165 | cpu->watchpoint_hit->vaddr); | |
166 | g_string_printf(buf, "T%02xthread:%s;%swatch:%" VADDR_PRIx ";", | |
167 | GDB_SIGNAL_TRAP, tid->str, type, | |
168 | cpu->watchpoint_hit->vaddr); | |
169 | cpu->watchpoint_hit = NULL; | |
170 | goto send_packet; | |
171 | } else { | |
172 | trace_gdbstub_hit_break(); | |
173 | } | |
174 | tb_flush(cpu); | |
175 | ret = GDB_SIGNAL_TRAP; | |
176 | break; | |
177 | case RUN_STATE_PAUSED: | |
178 | trace_gdbstub_hit_paused(); | |
179 | ret = GDB_SIGNAL_INT; | |
180 | break; | |
181 | case RUN_STATE_SHUTDOWN: | |
182 | trace_gdbstub_hit_shutdown(); | |
183 | ret = GDB_SIGNAL_QUIT; | |
184 | break; | |
185 | case RUN_STATE_IO_ERROR: | |
186 | trace_gdbstub_hit_io_error(); | |
187 | ret = GDB_SIGNAL_IO; | |
188 | break; | |
189 | case RUN_STATE_WATCHDOG: | |
190 | trace_gdbstub_hit_watchdog(); | |
191 | ret = GDB_SIGNAL_ALRM; | |
192 | break; | |
193 | case RUN_STATE_INTERNAL_ERROR: | |
194 | trace_gdbstub_hit_internal_error(); | |
195 | ret = GDB_SIGNAL_ABRT; | |
196 | break; | |
197 | case RUN_STATE_SAVE_VM: | |
198 | case RUN_STATE_RESTORE_VM: | |
199 | return; | |
200 | case RUN_STATE_FINISH_MIGRATE: | |
201 | ret = GDB_SIGNAL_XCPU; | |
202 | break; | |
203 | default: | |
204 | trace_gdbstub_hit_unknown(state); | |
205 | ret = GDB_SIGNAL_UNKNOWN; | |
206 | break; | |
207 | } | |
208 | gdb_set_stop_cpu(cpu); | |
209 | g_string_printf(buf, "T%02xthread:%s;", ret, tid->str); | |
210 | ||
211 | send_packet: | |
212 | gdb_put_packet(buf->str); | |
75837005 | 213 | gdbserver_state.allow_stop_reply = false; |
b6fa2ec2 AB |
214 | |
215 | /* disable single step if it was enabled */ | |
216 | cpu_single_step(cpu, 0); | |
217 | } | |
218 | ||
219 | #ifndef _WIN32 | |
220 | static void gdb_sigterm_handler(int signal) | |
221 | { | |
222 | if (runstate_is_running()) { | |
223 | vm_stop(RUN_STATE_PAUSED); | |
224 | } | |
225 | } | |
226 | #endif | |
227 | ||
228 | static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len) | |
229 | { | |
230 | g_autoptr(GString) hex_buf = g_string_new("O"); | |
231 | gdb_memtohex(hex_buf, buf, len); | |
232 | gdb_put_packet(hex_buf->str); | |
233 | return len; | |
234 | } | |
235 | ||
236 | static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend, | |
237 | bool *be_opened, Error **errp) | |
238 | { | |
239 | *be_opened = false; | |
240 | } | |
241 | ||
242 | static void char_gdb_class_init(ObjectClass *oc, void *data) | |
243 | { | |
244 | ChardevClass *cc = CHARDEV_CLASS(oc); | |
245 | ||
246 | cc->internal = true; | |
247 | cc->open = gdb_monitor_open; | |
248 | cc->chr_write = gdb_monitor_write; | |
249 | } | |
250 | ||
251 | #define TYPE_CHARDEV_GDB "chardev-gdb" | |
252 | ||
253 | static const TypeInfo char_gdb_type_info = { | |
254 | .name = TYPE_CHARDEV_GDB, | |
255 | .parent = TYPE_CHARDEV, | |
256 | .class_init = char_gdb_class_init, | |
257 | }; | |
258 | ||
259 | static int gdb_chr_can_receive(void *opaque) | |
260 | { | |
261 | /* | |
262 | * We can handle an arbitrarily large amount of data. | |
263 | * Pick the maximum packet size, which is as good as anything. | |
264 | */ | |
265 | return MAX_PACKET_LENGTH; | |
266 | } | |
267 | ||
268 | static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size) | |
269 | { | |
270 | int i; | |
271 | ||
272 | for (i = 0; i < size; i++) { | |
273 | gdb_read_byte(buf[i]); | |
274 | } | |
275 | } | |
276 | ||
277 | static int find_cpu_clusters(Object *child, void *opaque) | |
278 | { | |
279 | if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) { | |
280 | GDBState *s = (GDBState *) opaque; | |
281 | CPUClusterState *cluster = CPU_CLUSTER(child); | |
282 | GDBProcess *process; | |
283 | ||
284 | s->processes = g_renew(GDBProcess, s->processes, ++s->process_num); | |
285 | ||
286 | process = &s->processes[s->process_num - 1]; | |
287 | ||
288 | /* | |
289 | * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at | |
290 | * runtime, we enforce here that the machine does not use a cluster ID | |
291 | * that would lead to PID 0. | |
292 | */ | |
293 | assert(cluster->cluster_id != UINT32_MAX); | |
294 | process->pid = cluster->cluster_id + 1; | |
295 | process->attached = false; | |
296 | process->target_xml[0] = '\0'; | |
297 | ||
298 | return 0; | |
299 | } | |
300 | ||
301 | return object_child_foreach(child, find_cpu_clusters, opaque); | |
302 | } | |
303 | ||
304 | static int pid_order(const void *a, const void *b) | |
305 | { | |
306 | GDBProcess *pa = (GDBProcess *) a; | |
307 | GDBProcess *pb = (GDBProcess *) b; | |
308 | ||
309 | if (pa->pid < pb->pid) { | |
310 | return -1; | |
311 | } else if (pa->pid > pb->pid) { | |
312 | return 1; | |
313 | } else { | |
314 | return 0; | |
315 | } | |
316 | } | |
317 | ||
318 | static void create_processes(GDBState *s) | |
319 | { | |
320 | object_child_foreach(object_get_root(), find_cpu_clusters, s); | |
321 | ||
322 | if (gdbserver_state.processes) { | |
323 | /* Sort by PID */ | |
324 | qsort(gdbserver_state.processes, | |
325 | gdbserver_state.process_num, | |
326 | sizeof(gdbserver_state.processes[0]), | |
327 | pid_order); | |
328 | } | |
329 | ||
330 | gdb_create_default_process(s); | |
331 | } | |
332 | ||
333 | int gdbserver_start(const char *device) | |
334 | { | |
b6fa2ec2 AB |
335 | Chardev *chr = NULL; |
336 | Chardev *mon_chr; | |
d2fe2264 | 337 | g_autoptr(GString) cs = g_string_new(device); |
b6fa2ec2 AB |
338 | |
339 | if (!first_cpu) { | |
340 | error_report("gdbstub: meaningless to attach gdb to a " | |
341 | "machine without any CPU."); | |
342 | return -1; | |
343 | } | |
344 | ||
345 | if (!gdb_supports_guest_debug()) { | |
346 | error_report("gdbstub: current accelerator doesn't " | |
347 | "support guest debugging"); | |
348 | return -1; | |
349 | } | |
350 | ||
d2fe2264 | 351 | if (cs->len == 0) { |
b6fa2ec2 AB |
352 | return -1; |
353 | } | |
d2fe2264 AB |
354 | |
355 | trace_gdbstub_op_start(cs->str); | |
356 | ||
357 | if (g_strcmp0(cs->str, "none") != 0) { | |
358 | if (g_str_has_prefix(cs->str, "tcp:")) { | |
b6fa2ec2 | 359 | /* enforce required TCP attributes */ |
d2fe2264 | 360 | g_string_append_printf(cs, ",wait=off,nodelay=on,server=on"); |
b6fa2ec2 AB |
361 | } |
362 | #ifndef _WIN32 | |
363 | else if (strcmp(device, "stdio") == 0) { | |
364 | struct sigaction act; | |
365 | ||
366 | memset(&act, 0, sizeof(act)); | |
367 | act.sa_handler = gdb_sigterm_handler; | |
368 | sigaction(SIGINT, &act, NULL); | |
369 | } | |
370 | #endif | |
371 | /* | |
372 | * FIXME: it's a bit weird to allow using a mux chardev here | |
373 | * and implicitly setup a monitor. We may want to break this. | |
374 | */ | |
d2fe2264 | 375 | chr = qemu_chr_new_noreplay("gdb", cs->str, true, NULL); |
b6fa2ec2 AB |
376 | if (!chr) { |
377 | return -1; | |
378 | } | |
379 | } | |
380 | ||
381 | if (!gdbserver_state.init) { | |
382 | gdb_init_gdbserver_state(); | |
383 | ||
384 | qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL); | |
385 | ||
386 | /* Initialize a monitor terminal for gdb */ | |
387 | mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB, | |
388 | NULL, NULL, &error_abort); | |
389 | monitor_init_hmp(mon_chr, false, &error_abort); | |
390 | } else { | |
391 | qemu_chr_fe_deinit(&gdbserver_system_state.chr, true); | |
392 | mon_chr = gdbserver_system_state.mon_chr; | |
393 | reset_gdbserver_state(); | |
394 | } | |
395 | ||
396 | create_processes(&gdbserver_state); | |
397 | ||
398 | if (chr) { | |
399 | qemu_chr_fe_init(&gdbserver_system_state.chr, chr, &error_abort); | |
400 | qemu_chr_fe_set_handlers(&gdbserver_system_state.chr, | |
401 | gdb_chr_can_receive, | |
402 | gdb_chr_receive, gdb_chr_event, | |
403 | NULL, &gdbserver_state, NULL, true); | |
404 | } | |
405 | gdbserver_state.state = chr ? RS_IDLE : RS_INACTIVE; | |
406 | gdbserver_system_state.mon_chr = mon_chr; | |
c566080c | 407 | gdb_syscall_reset(); |
b6fa2ec2 AB |
408 | |
409 | return 0; | |
410 | } | |
411 | ||
412 | static void register_types(void) | |
413 | { | |
414 | type_register_static(&char_gdb_type_info); | |
415 | } | |
416 | ||
417 | type_init(register_types); | |
418 | ||
419 | /* Tell the remote gdb that the process has exited. */ | |
420 | void gdb_exit(int code) | |
421 | { | |
422 | char buf[4]; | |
423 | ||
424 | if (!gdbserver_state.init) { | |
425 | return; | |
426 | } | |
427 | ||
428 | trace_gdbstub_op_exiting((uint8_t)code); | |
429 | ||
75837005 MTB |
430 | if (gdbserver_state.allow_stop_reply) { |
431 | snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code); | |
432 | gdb_put_packet(buf); | |
433 | gdbserver_state.allow_stop_reply = false; | |
434 | } | |
b6fa2ec2 AB |
435 | |
436 | qemu_chr_fe_deinit(&gdbserver_system_state.chr, true); | |
437 | } | |
438 | ||
589a5867 AB |
439 | /* |
440 | * Memory access | |
441 | */ | |
442 | static int phy_memory_mode; | |
443 | ||
444 | int gdb_target_memory_rw_debug(CPUState *cpu, hwaddr addr, | |
445 | uint8_t *buf, int len, bool is_write) | |
446 | { | |
447 | CPUClass *cc; | |
448 | ||
449 | if (phy_memory_mode) { | |
450 | if (is_write) { | |
451 | cpu_physical_memory_write(addr, buf, len); | |
452 | } else { | |
453 | cpu_physical_memory_read(addr, buf, len); | |
454 | } | |
455 | return 0; | |
456 | } | |
457 | ||
458 | cc = CPU_GET_CLASS(cpu); | |
459 | if (cc->memory_rw_debug) { | |
460 | return cc->memory_rw_debug(cpu, addr, buf, len, is_write); | |
461 | } | |
462 | ||
463 | return cpu_memory_rw_debug(cpu, addr, buf, len, is_write); | |
464 | } | |
465 | ||
7ea0c33d AB |
466 | /* |
467 | * cpu helpers | |
468 | */ | |
469 | ||
470 | unsigned int gdb_get_max_cpus(void) | |
471 | { | |
472 | MachineState *ms = MACHINE(qdev_get_machine()); | |
473 | return ms->smp.max_cpus; | |
474 | } | |
589a5867 | 475 | |
505601d5 AB |
476 | bool gdb_can_reverse(void) |
477 | { | |
478 | return replay_mode == REPLAY_MODE_PLAY; | |
479 | } | |
480 | ||
b6fa2ec2 AB |
481 | /* |
482 | * Softmmu specific command helpers | |
483 | */ | |
589a5867 AB |
484 | |
485 | void gdb_handle_query_qemu_phy_mem_mode(GArray *params, | |
486 | void *user_ctx) | |
487 | { | |
488 | g_string_printf(gdbserver_state.str_buf, "%d", phy_memory_mode); | |
489 | gdb_put_strbuf(); | |
490 | } | |
491 | ||
492 | void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *user_ctx) | |
493 | { | |
494 | if (!params->len) { | |
495 | gdb_put_packet("E22"); | |
496 | return; | |
497 | } | |
498 | ||
499 | if (!get_param(params, 0)->val_ul) { | |
500 | phy_memory_mode = 0; | |
501 | } else { | |
502 | phy_memory_mode = 1; | |
503 | } | |
504 | gdb_put_packet("OK"); | |
505 | } | |
506 | ||
b6fa2ec2 AB |
507 | void gdb_handle_query_rcmd(GArray *params, void *user_ctx) |
508 | { | |
509 | const guint8 zero = 0; | |
510 | int len; | |
511 | ||
512 | if (!params->len) { | |
513 | gdb_put_packet("E22"); | |
514 | return; | |
515 | } | |
516 | ||
517 | len = strlen(get_param(params, 0)->data); | |
518 | if (len % 2) { | |
519 | gdb_put_packet("E01"); | |
520 | return; | |
521 | } | |
522 | ||
523 | g_assert(gdbserver_state.mem_buf->len == 0); | |
524 | len = len / 2; | |
525 | gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len); | |
526 | g_byte_array_append(gdbserver_state.mem_buf, &zero, 1); | |
527 | qemu_chr_be_write(gdbserver_system_state.mon_chr, | |
528 | gdbserver_state.mem_buf->data, | |
529 | gdbserver_state.mem_buf->len); | |
530 | gdb_put_packet("OK"); | |
531 | } | |
532 | ||
d96bf49b AB |
533 | /* |
534 | * Execution state helpers | |
535 | */ | |
536 | ||
8a2025b3 AB |
537 | void gdb_handle_query_attached(GArray *params, void *user_ctx) |
538 | { | |
539 | gdb_put_packet("1"); | |
540 | } | |
541 | ||
d96bf49b AB |
542 | void gdb_continue(void) |
543 | { | |
544 | if (!runstate_needs_reset()) { | |
545 | trace_gdbstub_op_continue(); | |
546 | vm_start(); | |
547 | } | |
548 | } | |
549 | ||
550 | /* | |
551 | * Resume execution, per CPU actions. | |
552 | */ | |
553 | int gdb_continue_partial(char *newstates) | |
554 | { | |
555 | CPUState *cpu; | |
556 | int res = 0; | |
557 | int flag = 0; | |
558 | ||
559 | if (!runstate_needs_reset()) { | |
560 | bool step_requested = false; | |
561 | CPU_FOREACH(cpu) { | |
562 | if (newstates[cpu->cpu_index] == 's') { | |
563 | step_requested = true; | |
564 | break; | |
565 | } | |
566 | } | |
567 | ||
568 | if (vm_prepare_start(step_requested)) { | |
569 | return 0; | |
570 | } | |
571 | ||
572 | CPU_FOREACH(cpu) { | |
573 | switch (newstates[cpu->cpu_index]) { | |
574 | case 0: | |
575 | case 1: | |
576 | break; /* nothing to do here */ | |
577 | case 's': | |
578 | trace_gdbstub_op_stepping(cpu->cpu_index); | |
579 | cpu_single_step(cpu, gdbserver_state.sstep_flags); | |
580 | cpu_resume(cpu); | |
581 | flag = 1; | |
582 | break; | |
583 | case 'c': | |
584 | trace_gdbstub_op_continue_cpu(cpu->cpu_index); | |
585 | cpu_resume(cpu); | |
586 | flag = 1; | |
587 | break; | |
588 | default: | |
589 | res = -1; | |
590 | break; | |
591 | } | |
592 | } | |
593 | } | |
594 | if (flag) { | |
595 | qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true); | |
596 | } | |
597 | return res; | |
598 | } | |
599 | ||
600 | /* | |
601 | * Signal Handling - in system mode we only need SIGINT and SIGTRAP; other | |
602 | * signals are not yet supported. | |
603 | */ | |
604 | ||
605 | enum { | |
606 | TARGET_SIGINT = 2, | |
607 | TARGET_SIGTRAP = 5 | |
608 | }; | |
609 | ||
d96bf49b AB |
610 | int gdb_signal_to_target(int sig) |
611 | { | |
ccd4c7c2 AB |
612 | switch (sig) { |
613 | case 2: | |
614 | return TARGET_SIGINT; | |
615 | case 5: | |
616 | return TARGET_SIGTRAP; | |
617 | default: | |
d96bf49b AB |
618 | return -1; |
619 | } | |
620 | } | |
621 | ||
b6fa2ec2 AB |
622 | /* |
623 | * Break/Watch point helpers | |
624 | */ | |
625 | ||
a48e7d9e AB |
626 | bool gdb_supports_guest_debug(void) |
627 | { | |
628 | const AccelOpsClass *ops = cpus_get_accel(); | |
629 | if (ops->supports_guest_debug) { | |
630 | return ops->supports_guest_debug(); | |
631 | } | |
632 | return false; | |
633 | } | |
634 | ||
55b5b8e9 | 635 | int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len) |
ae7467b1 AB |
636 | { |
637 | const AccelOpsClass *ops = cpus_get_accel(); | |
638 | if (ops->insert_breakpoint) { | |
639 | return ops->insert_breakpoint(cs, type, addr, len); | |
640 | } | |
641 | return -ENOSYS; | |
642 | } | |
643 | ||
55b5b8e9 | 644 | int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len) |
ae7467b1 AB |
645 | { |
646 | const AccelOpsClass *ops = cpus_get_accel(); | |
647 | if (ops->remove_breakpoint) { | |
648 | return ops->remove_breakpoint(cs, type, addr, len); | |
649 | } | |
650 | return -ENOSYS; | |
651 | } | |
652 | ||
653 | void gdb_breakpoint_remove_all(CPUState *cs) | |
654 | { | |
655 | const AccelOpsClass *ops = cpus_get_accel(); | |
656 | if (ops->remove_all_breakpoints) { | |
657 | ops->remove_all_breakpoints(cs); | |
658 | } | |
659 | } |