Alex Bennée | ae7467b | 2022-09-29 12:42:24 +0100 | [diff] [blame] | 1 | /* |
| 2 | * gdbstub internals |
| 3 | * |
| 4 | * Copyright (c) 2022 Linaro Ltd |
| 5 | * |
| 6 | * SPDX-License-Identifier: GPL-2.0-or-later |
| 7 | */ |
| 8 | |
Alex Bennée | 9774855 | 2023-03-02 18:57:37 -0800 | [diff] [blame] | 9 | #ifndef GDBSTUB_INTERNALS_H |
| 10 | #define GDBSTUB_INTERNALS_H |
Alex Bennée | ae7467b | 2022-09-29 12:42:24 +0100 | [diff] [blame] | 11 | |
Philippe Mathieu-Daudé | 55b5b8e | 2022-12-06 16:20:27 +0100 | [diff] [blame] | 12 | #include "exec/cpu-common.h" |
| 13 | |
Alex Bennée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 14 | #define MAX_PACKET_LENGTH 4096 |
| 15 | |
| 16 | /* |
| 17 | * Shared structures and definitions |
| 18 | */ |
| 19 | |
Alex Bennée | b6fa2ec | 2023-03-02 18:57:46 -0800 | [diff] [blame] | 20 | enum { |
| 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ée | 5dcf633 | 2023-12-01 09:36:27 +0000 | [diff] [blame] | 27 | GDB_SIGNAL_STOP = 17, |
Alex Bennée | b6fa2ec | 2023-03-02 18:57:46 -0800 | [diff] [blame] | 28 | GDB_SIGNAL_IO = 23, |
| 29 | GDB_SIGNAL_XCPU = 24, |
| 30 | GDB_SIGNAL_UNKNOWN = 143 |
| 31 | }; |
| 32 | |
Alex Bennée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 33 | typedef struct GDBProcess { |
| 34 | uint32_t pid; |
| 35 | bool attached; |
Alex Bennée | 56e534b | 2023-08-29 17:15:26 +0100 | [diff] [blame] | 36 | char *target_xml; |
Alex Bennée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 37 | } GDBProcess; |
| 38 | |
| 39 | enum 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 | |
| 49 | typedef 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ée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 64 | GString *str_buf; |
| 65 | GByteArray *mem_buf; |
| 66 | int sstep_flags; |
| 67 | int supported_sstep_flags; |
Matheus Tavares Bernardino | 7583700 | 2023-05-04 12:37:31 -0300 | [diff] [blame] | 68 | /* |
| 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ée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 73 | } GDBState; |
| 74 | |
Alex Bennée | b6fa2ec | 2023-03-02 18:57:46 -0800 | [diff] [blame] | 75 | /* lives in main gdbstub.c */ |
| 76 | extern GDBState gdbserver_state; |
Alex Bennée | 1678ea0 | 2023-03-02 18:57:44 -0800 | [diff] [blame] | 77 | |
| 78 | /* |
| 79 | * Inline utility function, convert from int to hex and back |
| 80 | */ |
| 81 | |
| 82 | static 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 | |
| 95 | static 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ée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 104 | /* |
Philippe Mathieu-Daudé | 3f7d1bd | 2023-10-04 11:06:22 +0200 | [diff] [blame] | 105 | * Connection helpers for both system and user backends |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 106 | */ |
| 107 | |
| 108 | void gdb_put_strbuf(void); |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 109 | int gdb_put_packet_binary(const char *buf, int len, bool dump); |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 110 | void gdb_memtohex(GString *buf, const uint8_t *mem, int len); |
| 111 | void gdb_memtox(GString *buf, const char *mem, int len); |
| 112 | void gdb_read_byte(uint8_t ch); |
| 113 | |
Alex Bennée | a7e0f9b | 2023-03-02 18:57:49 -0800 | [diff] [blame] | 114 | /* |
| 115 | * Packet acknowledgement - we handle this slightly differently |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 116 | * between user and system mode, mainly to deal with the differences |
Alex Bennée | a7e0f9b | 2023-03-02 18:57:49 -0800 | [diff] [blame] | 117 | * 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é | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 126 | * system stub always returns true. |
Alex Bennée | a7e0f9b | 2023-03-02 18:57:49 -0800 | [diff] [blame] | 127 | */ |
| 128 | bool gdb_got_immediate_ack(void); |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 129 | /* utility helpers */ |
Ilya Leoshkevich | a3fcc11 | 2023-06-30 19:04:19 +0100 | [diff] [blame] | 130 | GDBProcess *gdb_get_process(uint32_t pid); |
| 131 | CPUState *gdb_get_first_cpu_in_process(GDBProcess *process); |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 132 | CPUState *gdb_first_attached_cpu(void); |
| 133 | void gdb_append_thread_id(CPUState *cpu, GString *buf); |
| 134 | int gdb_get_cpu_index(CPUState *cpu); |
Alex Bennée | 7ea0c33 | 2023-03-02 18:57:52 -0800 | [diff] [blame] | 135 | unsigned int gdb_get_max_cpus(void); /* both */ |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 136 | bool gdb_can_reverse(void); /* system emulation, stub for user */ |
Ilya Leoshkevich | 4aad096 | 2024-02-07 16:38:08 +0000 | [diff] [blame] | 137 | int gdb_target_sigtrap(void); /* user */ |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 138 | |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 139 | void gdb_create_default_process(GDBState *s); |
| 140 | |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 141 | /* signal mapping, common for system, specialised for user-mode */ |
Alex Bennée | d96bf49 | 2023-03-02 18:57:47 -0800 | [diff] [blame] | 142 | int gdb_signal_to_target(int sig); |
| 143 | int gdb_target_signal_to_gdb(int sig); |
| 144 | |
| 145 | int gdb_get_char(void); /* user only */ |
| 146 | |
| 147 | /** |
| 148 | * gdb_continue() - handle continue in mode specific way. |
| 149 | */ |
| 150 | void gdb_continue(void); |
| 151 | |
| 152 | /** |
| 153 | * gdb_continue_partial() - handle partial continue in mode specific way. |
| 154 | */ |
| 155 | int gdb_continue_partial(char *newstates); |
| 156 | |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 157 | /* |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 158 | * Helpers with separate system and user implementations |
Alex Bennée | 36e067b | 2023-03-02 18:57:45 -0800 | [diff] [blame] | 159 | */ |
| 160 | void gdb_put_buffer(const uint8_t *buf, int len); |
| 161 | |
| 162 | /* |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 163 | * Command handlers - either specialised or system or user only |
Alex Bennée | b6fa2ec | 2023-03-02 18:57:46 -0800 | [diff] [blame] | 164 | */ |
| 165 | void gdb_init_gdbserver_state(void); |
| 166 | |
Philippe Mathieu-Daudé | 0eaf7fb | 2024-03-13 21:12:36 +0100 | [diff] [blame] | 167 | void gdb_handle_query_rcmd(GArray *params, void *ctx); /* system */ |
Alex Bennée | d96bf49 | 2023-03-02 18:57:47 -0800 | [diff] [blame] | 168 | void gdb_handle_query_offsets(GArray *params, void *user_ctx); /* user */ |
| 169 | void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx); /*user */ |
Gustavo Romero | 9ae5801 | 2024-03-09 03:09:00 +0000 | [diff] [blame] | 170 | void gdb_handle_query_xfer_siginfo(GArray *params, void *user_ctx); /*user */ |
Ilya Leoshkevich | e282010 | 2023-06-30 19:04:21 +0100 | [diff] [blame] | 171 | void gdb_handle_v_file_open(GArray *params, void *user_ctx); /* user */ |
| 172 | void gdb_handle_v_file_close(GArray *params, void *user_ctx); /* user */ |
| 173 | void gdb_handle_v_file_pread(GArray *params, void *user_ctx); /* user */ |
| 174 | void gdb_handle_v_file_readlink(GArray *params, void *user_ctx); /* user */ |
| 175 | void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx); /* user */ |
Ilya Leoshkevich | 046f143 | 2024-02-07 16:38:11 +0000 | [diff] [blame] | 176 | void gdb_handle_set_catch_syscalls(GArray *params, void *user_ctx); /* user */ |
Ilya Leoshkevich | 6d92311 | 2024-03-05 12:09:45 +0000 | [diff] [blame] | 177 | void gdb_handle_query_supported_user(const char *gdb_supported); /* user */ |
Ilya Leoshkevich | e454f2f | 2024-03-05 12:09:46 +0000 | [diff] [blame] | 178 | bool gdb_handle_set_thread_user(uint32_t pid, uint32_t tid); /* user */ |
Ilya Leoshkevich | 539cb4e | 2024-03-05 12:09:47 +0000 | [diff] [blame] | 179 | bool gdb_handle_detach_user(uint32_t pid); /* user */ |
Alex Bennée | b6fa2ec | 2023-03-02 18:57:46 -0800 | [diff] [blame] | 180 | |
Philippe Mathieu-Daudé | 0eaf7fb | 2024-03-13 21:12:36 +0100 | [diff] [blame] | 181 | void gdb_handle_query_attached(GArray *params, void *ctx); /* both */ |
Alex Bennée | 8a2025b | 2023-03-02 18:57:50 -0800 | [diff] [blame] | 182 | |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 183 | /* system only */ |
Philippe Mathieu-Daudé | 0eaf7fb | 2024-03-13 21:12:36 +0100 | [diff] [blame] | 184 | void gdb_handle_query_qemu_phy_mem_mode(GArray *params, void *ctx); |
| 185 | void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *ctx); |
Alex Bennée | 589a586 | 2023-03-02 18:57:51 -0800 | [diff] [blame] | 186 | |
Alex Bennée | c566080 | 2023-03-02 18:57:57 -0800 | [diff] [blame] | 187 | /* sycall handling */ |
| 188 | void gdb_handle_file_io(GArray *params, void *user_ctx); |
| 189 | bool gdb_handled_syscall(void); |
| 190 | void gdb_disable_syscalls(void); |
| 191 | void gdb_syscall_reset(void); |
| 192 | |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 193 | /* user/system specific syscall handling */ |
Alex Bennée | 131f387 | 2023-03-02 18:58:01 -0800 | [diff] [blame] | 194 | void gdb_syscall_handling(const char *syscall_packet); |
| 195 | |
Alex Bennée | b6fa2ec | 2023-03-02 18:57:46 -0800 | [diff] [blame] | 196 | /* |
Philippe Mathieu-Daudé | 25f34eb | 2024-03-13 21:09:38 +0100 | [diff] [blame] | 197 | * Break/Watch point support - there is an implementation for system |
Alex Bennée | 9f56787 | 2023-03-02 18:57:42 -0800 | [diff] [blame] | 198 | * and user mode. |
| 199 | */ |
Alex Bennée | a48e7d9 | 2022-09-29 12:42:25 +0100 | [diff] [blame] | 200 | bool gdb_supports_guest_debug(void); |
Philippe Mathieu-Daudé | 55b5b8e | 2022-12-06 16:20:27 +0100 | [diff] [blame] | 201 | int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len); |
| 202 | int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len); |
Alex Bennée | ae7467b | 2022-09-29 12:42:24 +0100 | [diff] [blame] | 203 | void gdb_breakpoint_remove_all(CPUState *cs); |
| 204 | |
Alex Bennée | 589a586 | 2023-03-02 18:57:51 -0800 | [diff] [blame] | 205 | /** |
| 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é | 3f7d1bd | 2023-10-04 11:06:22 +0200 | [diff] [blame] | 214 | * in. For system guests we can switch the interpretation of the |
Alex Bennée | 589a586 | 2023-03-02 18:57:51 -0800 | [diff] [blame] | 215 | * address to a physical address. |
| 216 | */ |
| 217 | int gdb_target_memory_rw_debug(CPUState *cs, hwaddr addr, |
| 218 | uint8_t *buf, int len, bool is_write); |
| 219 | |
Alex Bennée | 9774855 | 2023-03-02 18:57:37 -0800 | [diff] [blame] | 220 | #endif /* GDBSTUB_INTERNALS_H */ |