blob: bf5a5c63029c998cb0e64cd73076ceb7b02953a6 [file] [log] [blame]
Alex Bennéeae7467b2022-09-29 12:42:24 +01001/*
2 * gdbstub internals
3 *
4 * Copyright (c) 2022 Linaro Ltd
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
Alex Bennée97748552023-03-02 18:57:37 -08009#ifndef GDBSTUB_INTERNALS_H
10#define GDBSTUB_INTERNALS_H
Alex Bennéeae7467b2022-09-29 12:42:24 +010011
Philippe Mathieu-Daudé55b5b8e2022-12-06 16:20:27 +010012#include "exec/cpu-common.h"
13
Alex Bennée9f567872023-03-02 18:57:42 -080014#define MAX_PACKET_LENGTH 4096
15
16/*
17 * Shared structures and definitions
18 */
19
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -080020enum {
21 GDB_SIGNAL_0 = 0,
22 GDB_SIGNAL_INT = 2,
23 GDB_SIGNAL_QUIT = 3,
24 GDB_SIGNAL_TRAP = 5,
25 GDB_SIGNAL_ABRT = 6,
26 GDB_SIGNAL_ALRM = 14,
Alex Bennée5dcf6332023-12-01 09:36:27 +000027 GDB_SIGNAL_STOP = 17,
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -080028 GDB_SIGNAL_IO = 23,
29 GDB_SIGNAL_XCPU = 24,
30 GDB_SIGNAL_UNKNOWN = 143
31};
32
Alex Bennée9f567872023-03-02 18:57:42 -080033typedef struct GDBProcess {
34 uint32_t pid;
35 bool attached;
Alex Bennée56e534b2023-08-29 17:15:26 +010036 char *target_xml;
Alex Bennée9f567872023-03-02 18:57:42 -080037} GDBProcess;
38
39enum RSState {
40 RS_INACTIVE,
41 RS_IDLE,
42 RS_GETLINE,
43 RS_GETLINE_ESC,
44 RS_GETLINE_RLE,
45 RS_CHKSUM1,
46 RS_CHKSUM2,
47};
48
49typedef struct GDBState {
50 bool init; /* have we been initialised? */
51 CPUState *c_cpu; /* current CPU for step/continue ops */
52 CPUState *g_cpu; /* current CPU for other ops */
53 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
54 enum RSState state; /* parsing state */
55 char line_buf[MAX_PACKET_LENGTH];
56 int line_buf_index;
57 int line_sum; /* running checksum */
58 int line_csum; /* checksum at the end of the packet */
59 GByteArray *last_packet;
60 int signal;
61 bool multiprocess;
62 GDBProcess *processes;
63 int process_num;
Alex Bennée9f567872023-03-02 18:57:42 -080064 GString *str_buf;
65 GByteArray *mem_buf;
66 int sstep_flags;
67 int supported_sstep_flags;
Matheus Tavares Bernardino75837002023-05-04 12:37:31 -030068 /*
69 * Whether we are allowed to send a stop reply packet at this moment.
70 * Must be set off after sending the stop reply itself.
71 */
72 bool allow_stop_reply;
Alex Bennée9f567872023-03-02 18:57:42 -080073} GDBState;
74
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -080075/* lives in main gdbstub.c */
76extern GDBState gdbserver_state;
Alex Bennée1678ea02023-03-02 18:57:44 -080077
78/*
79 * Inline utility function, convert from int to hex and back
80 */
81
82static inline int fromhex(int v)
83{
84 if (v >= '0' && v <= '9') {
85 return v - '0';
86 } else if (v >= 'A' && v <= 'F') {
87 return v - 'A' + 10;
88 } else if (v >= 'a' && v <= 'f') {
89 return v - 'a' + 10;
90 } else {
91 return 0;
92 }
93}
94
95static inline int tohex(int v)
96{
97 if (v < 10) {
98 return v + '0';
99 } else {
100 return v - 10 + 'a';
101 }
102}
103
Alex Bennée9f567872023-03-02 18:57:42 -0800104/*
Philippe Mathieu-Daudé3f7d1bd2023-10-04 11:06:22 +0200105 * Connection helpers for both system and user backends
Alex Bennée36e067b2023-03-02 18:57:45 -0800106 */
107
108void gdb_put_strbuf(void);
Alex Bennée36e067b2023-03-02 18:57:45 -0800109int gdb_put_packet_binary(const char *buf, int len, bool dump);
Alex Bennée36e067b2023-03-02 18:57:45 -0800110void gdb_memtohex(GString *buf, const uint8_t *mem, int len);
111void gdb_memtox(GString *buf, const char *mem, int len);
112void gdb_read_byte(uint8_t ch);
113
Alex Bennéea7e0f9b2023-03-02 18:57:49 -0800114/*
115 * Packet acknowledgement - we handle this slightly differently
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100116 * between user and system mode, mainly to deal with the differences
Alex Bennéea7e0f9b2023-03-02 18:57:49 -0800117 * between the flexible chardev and the direct fd approaches.
118 *
119 * We currently don't support a negotiated QStartNoAckMode
120 */
121
122/**
123 * gdb_got_immediate_ack() - check ok to continue
124 *
125 * Returns true to continue, false to re-transmit for user only, the
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100126 * system stub always returns true.
Alex Bennéea7e0f9b2023-03-02 18:57:49 -0800127 */
128bool gdb_got_immediate_ack(void);
Alex Bennée36e067b2023-03-02 18:57:45 -0800129/* utility helpers */
Ilya Leoshkevicha3fcc112023-06-30 19:04:19 +0100130GDBProcess *gdb_get_process(uint32_t pid);
131CPUState *gdb_get_first_cpu_in_process(GDBProcess *process);
Alex Bennée36e067b2023-03-02 18:57:45 -0800132CPUState *gdb_first_attached_cpu(void);
133void gdb_append_thread_id(CPUState *cpu, GString *buf);
134int gdb_get_cpu_index(CPUState *cpu);
Alex Bennée7ea0c332023-03-02 18:57:52 -0800135unsigned int gdb_get_max_cpus(void); /* both */
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100136bool gdb_can_reverse(void); /* system emulation, stub for user */
Ilya Leoshkevich4aad0962024-02-07 16:38:08 +0000137int gdb_target_sigtrap(void); /* user */
Alex Bennée36e067b2023-03-02 18:57:45 -0800138
Alex Bennée36e067b2023-03-02 18:57:45 -0800139void gdb_create_default_process(GDBState *s);
140
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100141/* signal mapping, common for system, specialised for user-mode */
Alex Bennéed96bf492023-03-02 18:57:47 -0800142int gdb_signal_to_target(int sig);
143int gdb_target_signal_to_gdb(int sig);
144
145int gdb_get_char(void); /* user only */
146
147/**
148 * gdb_continue() - handle continue in mode specific way.
149 */
150void gdb_continue(void);
151
152/**
153 * gdb_continue_partial() - handle partial continue in mode specific way.
154 */
155int gdb_continue_partial(char *newstates);
156
Alex Bennée36e067b2023-03-02 18:57:45 -0800157/*
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100158 * Helpers with separate system and user implementations
Alex Bennée36e067b2023-03-02 18:57:45 -0800159 */
160void gdb_put_buffer(const uint8_t *buf, int len);
161
162/*
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100163 * Command handlers - either specialised or system or user only
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -0800164 */
165void gdb_init_gdbserver_state(void);
166
Philippe Mathieu-Daudé0eaf7fb2024-03-13 21:12:36 +0100167void gdb_handle_query_rcmd(GArray *params, void *ctx); /* system */
Alex Bennéed96bf492023-03-02 18:57:47 -0800168void gdb_handle_query_offsets(GArray *params, void *user_ctx); /* user */
169void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx); /*user */
Gustavo Romero9ae58012024-03-09 03:09:00 +0000170void gdb_handle_query_xfer_siginfo(GArray *params, void *user_ctx); /*user */
Ilya Leoshkeviche2820102023-06-30 19:04:21 +0100171void gdb_handle_v_file_open(GArray *params, void *user_ctx); /* user */
172void gdb_handle_v_file_close(GArray *params, void *user_ctx); /* user */
173void gdb_handle_v_file_pread(GArray *params, void *user_ctx); /* user */
174void gdb_handle_v_file_readlink(GArray *params, void *user_ctx); /* user */
175void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx); /* user */
Ilya Leoshkevich046f1432024-02-07 16:38:11 +0000176void gdb_handle_set_catch_syscalls(GArray *params, void *user_ctx); /* user */
Ilya Leoshkevich6d923112024-03-05 12:09:45 +0000177void gdb_handle_query_supported_user(const char *gdb_supported); /* user */
Ilya Leoshkeviche454f2f2024-03-05 12:09:46 +0000178bool gdb_handle_set_thread_user(uint32_t pid, uint32_t tid); /* user */
Ilya Leoshkevich539cb4e2024-03-05 12:09:47 +0000179bool gdb_handle_detach_user(uint32_t pid); /* user */
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -0800180
Philippe Mathieu-Daudé0eaf7fb2024-03-13 21:12:36 +0100181void gdb_handle_query_attached(GArray *params, void *ctx); /* both */
Alex Bennée8a2025b2023-03-02 18:57:50 -0800182
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100183/* system only */
Philippe Mathieu-Daudé0eaf7fb2024-03-13 21:12:36 +0100184void gdb_handle_query_qemu_phy_mem_mode(GArray *params, void *ctx);
185void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *ctx);
Alex Bennée589a5862023-03-02 18:57:51 -0800186
Alex Bennéec5660802023-03-02 18:57:57 -0800187/* sycall handling */
188void gdb_handle_file_io(GArray *params, void *user_ctx);
189bool gdb_handled_syscall(void);
190void gdb_disable_syscalls(void);
191void gdb_syscall_reset(void);
192
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100193/* user/system specific syscall handling */
Alex Bennée131f3872023-03-02 18:58:01 -0800194void gdb_syscall_handling(const char *syscall_packet);
195
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -0800196/*
Philippe Mathieu-Daudé25f34eb2024-03-13 21:09:38 +0100197 * Break/Watch point support - there is an implementation for system
Alex Bennée9f567872023-03-02 18:57:42 -0800198 * and user mode.
199 */
Alex Bennéea48e7d92022-09-29 12:42:25 +0100200bool gdb_supports_guest_debug(void);
Philippe Mathieu-Daudé55b5b8e2022-12-06 16:20:27 +0100201int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len);
202int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len);
Alex Bennéeae7467b2022-09-29 12:42:24 +0100203void gdb_breakpoint_remove_all(CPUState *cs);
204
Alex Bennée589a5862023-03-02 18:57:51 -0800205/**
206 * gdb_target_memory_rw_debug() - handle debug access to memory
207 * @cs: CPUState
208 * @addr: nominal address, could be an entire physical address
209 * @buf: data
210 * @len: length of access
211 * @is_write: is it a write operation
212 *
213 * This function is specialised depending on the mode we are running
Philippe Mathieu-Daudé3f7d1bd2023-10-04 11:06:22 +0200214 * in. For system guests we can switch the interpretation of the
Alex Bennée589a5862023-03-02 18:57:51 -0800215 * address to a physical address.
216 */
217int gdb_target_memory_rw_debug(CPUState *cs, hwaddr addr,
218 uint8_t *buf, int len, bool is_write);
219
Alex Bennée97748552023-03-02 18:57:37 -0800220#endif /* GDBSTUB_INTERNALS_H */