1*842b42dfSAlex Bennée /* 2*842b42dfSAlex Bennée * gdb server stub 3*842b42dfSAlex Bennée * 4*842b42dfSAlex Bennée * This implements a subset of the remote protocol as described in: 5*842b42dfSAlex Bennée * 6*842b42dfSAlex Bennée * https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html 7*842b42dfSAlex Bennée * 8*842b42dfSAlex Bennée * Copyright (c) 2003-2005 Fabrice Bellard 9*842b42dfSAlex Bennée * 10*842b42dfSAlex Bennée * This library is free software; you can redistribute it and/or 11*842b42dfSAlex Bennée * modify it under the terms of the GNU Lesser General Public 12*842b42dfSAlex Bennée * License as published by the Free Software Foundation; either 13*842b42dfSAlex Bennée * version 2 of the License, or (at your option) any later version. 14*842b42dfSAlex Bennée * 15*842b42dfSAlex Bennée * This library is distributed in the hope that it will be useful, 16*842b42dfSAlex Bennée * but WITHOUT ANY WARRANTY; without even the implied warranty of 17*842b42dfSAlex Bennée * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18*842b42dfSAlex Bennée * Lesser General Public License for more details. 19*842b42dfSAlex Bennée * 20*842b42dfSAlex Bennée * You should have received a copy of the GNU Lesser General Public 21*842b42dfSAlex Bennée * License along with this library; if not, see <http://www.gnu.org/licenses/>. 22*842b42dfSAlex Bennée * 23*842b42dfSAlex Bennée * SPDX-License-Identifier: LGPL-2.0+ 24*842b42dfSAlex Bennée */ 25*842b42dfSAlex Bennée 26*842b42dfSAlex Bennée #include "qemu/osdep.h" 27*842b42dfSAlex Bennée #include "qapi/error.h" 28*842b42dfSAlex Bennée #include "qemu/error-report.h" 29*842b42dfSAlex Bennée #include "qemu/ctype.h" 30*842b42dfSAlex Bennée #include "qemu/cutils.h" 31*842b42dfSAlex Bennée #include "qemu/module.h" 32*842b42dfSAlex Bennée #include "trace.h" 33*842b42dfSAlex Bennée #include "exec/gdbstub.h" 34*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 35*842b42dfSAlex Bennée #include "qemu.h" 36*842b42dfSAlex Bennée #else 37*842b42dfSAlex Bennée #include "monitor/monitor.h" 38*842b42dfSAlex Bennée #include "chardev/char.h" 39*842b42dfSAlex Bennée #include "chardev/char-fe.h" 40*842b42dfSAlex Bennée #include "hw/cpu/cluster.h" 41*842b42dfSAlex Bennée #include "hw/boards.h" 42*842b42dfSAlex Bennée #endif 43*842b42dfSAlex Bennée 44*842b42dfSAlex Bennée #define MAX_PACKET_LENGTH 4096 45*842b42dfSAlex Bennée 46*842b42dfSAlex Bennée #include "qemu/sockets.h" 47*842b42dfSAlex Bennée #include "sysemu/hw_accel.h" 48*842b42dfSAlex Bennée #include "sysemu/kvm.h" 49*842b42dfSAlex Bennée #include "sysemu/runstate.h" 50*842b42dfSAlex Bennée #include "semihosting/semihost.h" 51*842b42dfSAlex Bennée #include "exec/exec-all.h" 52*842b42dfSAlex Bennée #include "sysemu/replay.h" 53*842b42dfSAlex Bennée 54*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 55*842b42dfSAlex Bennée #define GDB_ATTACHED "0" 56*842b42dfSAlex Bennée #else 57*842b42dfSAlex Bennée #define GDB_ATTACHED "1" 58*842b42dfSAlex Bennée #endif 59*842b42dfSAlex Bennée 60*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 61*842b42dfSAlex Bennée static int phy_memory_mode; 62*842b42dfSAlex Bennée #endif 63*842b42dfSAlex Bennée 64*842b42dfSAlex Bennée static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr, 65*842b42dfSAlex Bennée uint8_t *buf, int len, bool is_write) 66*842b42dfSAlex Bennée { 67*842b42dfSAlex Bennée CPUClass *cc; 68*842b42dfSAlex Bennée 69*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 70*842b42dfSAlex Bennée if (phy_memory_mode) { 71*842b42dfSAlex Bennée if (is_write) { 72*842b42dfSAlex Bennée cpu_physical_memory_write(addr, buf, len); 73*842b42dfSAlex Bennée } else { 74*842b42dfSAlex Bennée cpu_physical_memory_read(addr, buf, len); 75*842b42dfSAlex Bennée } 76*842b42dfSAlex Bennée return 0; 77*842b42dfSAlex Bennée } 78*842b42dfSAlex Bennée #endif 79*842b42dfSAlex Bennée 80*842b42dfSAlex Bennée cc = CPU_GET_CLASS(cpu); 81*842b42dfSAlex Bennée if (cc->memory_rw_debug) { 82*842b42dfSAlex Bennée return cc->memory_rw_debug(cpu, addr, buf, len, is_write); 83*842b42dfSAlex Bennée } 84*842b42dfSAlex Bennée return cpu_memory_rw_debug(cpu, addr, buf, len, is_write); 85*842b42dfSAlex Bennée } 86*842b42dfSAlex Bennée 87*842b42dfSAlex Bennée /* Return the GDB index for a given vCPU state. 88*842b42dfSAlex Bennée * 89*842b42dfSAlex Bennée * For user mode this is simply the thread id. In system mode GDB 90*842b42dfSAlex Bennée * numbers CPUs from 1 as 0 is reserved as an "any cpu" index. 91*842b42dfSAlex Bennée */ 92*842b42dfSAlex Bennée static inline int cpu_gdb_index(CPUState *cpu) 93*842b42dfSAlex Bennée { 94*842b42dfSAlex Bennée #if defined(CONFIG_USER_ONLY) 95*842b42dfSAlex Bennée TaskState *ts = (TaskState *) cpu->opaque; 96*842b42dfSAlex Bennée return ts ? ts->ts_tid : -1; 97*842b42dfSAlex Bennée #else 98*842b42dfSAlex Bennée return cpu->cpu_index + 1; 99*842b42dfSAlex Bennée #endif 100*842b42dfSAlex Bennée } 101*842b42dfSAlex Bennée 102*842b42dfSAlex Bennée enum { 103*842b42dfSAlex Bennée GDB_SIGNAL_0 = 0, 104*842b42dfSAlex Bennée GDB_SIGNAL_INT = 2, 105*842b42dfSAlex Bennée GDB_SIGNAL_QUIT = 3, 106*842b42dfSAlex Bennée GDB_SIGNAL_TRAP = 5, 107*842b42dfSAlex Bennée GDB_SIGNAL_ABRT = 6, 108*842b42dfSAlex Bennée GDB_SIGNAL_ALRM = 14, 109*842b42dfSAlex Bennée GDB_SIGNAL_IO = 23, 110*842b42dfSAlex Bennée GDB_SIGNAL_XCPU = 24, 111*842b42dfSAlex Bennée GDB_SIGNAL_UNKNOWN = 143 112*842b42dfSAlex Bennée }; 113*842b42dfSAlex Bennée 114*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 115*842b42dfSAlex Bennée 116*842b42dfSAlex Bennée /* Map target signal numbers to GDB protocol signal numbers and vice 117*842b42dfSAlex Bennée * versa. For user emulation's currently supported systems, we can 118*842b42dfSAlex Bennée * assume most signals are defined. 119*842b42dfSAlex Bennée */ 120*842b42dfSAlex Bennée 121*842b42dfSAlex Bennée static int gdb_signal_table[] = { 122*842b42dfSAlex Bennée 0, 123*842b42dfSAlex Bennée TARGET_SIGHUP, 124*842b42dfSAlex Bennée TARGET_SIGINT, 125*842b42dfSAlex Bennée TARGET_SIGQUIT, 126*842b42dfSAlex Bennée TARGET_SIGILL, 127*842b42dfSAlex Bennée TARGET_SIGTRAP, 128*842b42dfSAlex Bennée TARGET_SIGABRT, 129*842b42dfSAlex Bennée -1, /* SIGEMT */ 130*842b42dfSAlex Bennée TARGET_SIGFPE, 131*842b42dfSAlex Bennée TARGET_SIGKILL, 132*842b42dfSAlex Bennée TARGET_SIGBUS, 133*842b42dfSAlex Bennée TARGET_SIGSEGV, 134*842b42dfSAlex Bennée TARGET_SIGSYS, 135*842b42dfSAlex Bennée TARGET_SIGPIPE, 136*842b42dfSAlex Bennée TARGET_SIGALRM, 137*842b42dfSAlex Bennée TARGET_SIGTERM, 138*842b42dfSAlex Bennée TARGET_SIGURG, 139*842b42dfSAlex Bennée TARGET_SIGSTOP, 140*842b42dfSAlex Bennée TARGET_SIGTSTP, 141*842b42dfSAlex Bennée TARGET_SIGCONT, 142*842b42dfSAlex Bennée TARGET_SIGCHLD, 143*842b42dfSAlex Bennée TARGET_SIGTTIN, 144*842b42dfSAlex Bennée TARGET_SIGTTOU, 145*842b42dfSAlex Bennée TARGET_SIGIO, 146*842b42dfSAlex Bennée TARGET_SIGXCPU, 147*842b42dfSAlex Bennée TARGET_SIGXFSZ, 148*842b42dfSAlex Bennée TARGET_SIGVTALRM, 149*842b42dfSAlex Bennée TARGET_SIGPROF, 150*842b42dfSAlex Bennée TARGET_SIGWINCH, 151*842b42dfSAlex Bennée -1, /* SIGLOST */ 152*842b42dfSAlex Bennée TARGET_SIGUSR1, 153*842b42dfSAlex Bennée TARGET_SIGUSR2, 154*842b42dfSAlex Bennée #ifdef TARGET_SIGPWR 155*842b42dfSAlex Bennée TARGET_SIGPWR, 156*842b42dfSAlex Bennée #else 157*842b42dfSAlex Bennée -1, 158*842b42dfSAlex Bennée #endif 159*842b42dfSAlex Bennée -1, /* SIGPOLL */ 160*842b42dfSAlex Bennée -1, 161*842b42dfSAlex Bennée -1, 162*842b42dfSAlex Bennée -1, 163*842b42dfSAlex Bennée -1, 164*842b42dfSAlex Bennée -1, 165*842b42dfSAlex Bennée -1, 166*842b42dfSAlex Bennée -1, 167*842b42dfSAlex Bennée -1, 168*842b42dfSAlex Bennée -1, 169*842b42dfSAlex Bennée -1, 170*842b42dfSAlex Bennée -1, 171*842b42dfSAlex Bennée #ifdef __SIGRTMIN 172*842b42dfSAlex Bennée __SIGRTMIN + 1, 173*842b42dfSAlex Bennée __SIGRTMIN + 2, 174*842b42dfSAlex Bennée __SIGRTMIN + 3, 175*842b42dfSAlex Bennée __SIGRTMIN + 4, 176*842b42dfSAlex Bennée __SIGRTMIN + 5, 177*842b42dfSAlex Bennée __SIGRTMIN + 6, 178*842b42dfSAlex Bennée __SIGRTMIN + 7, 179*842b42dfSAlex Bennée __SIGRTMIN + 8, 180*842b42dfSAlex Bennée __SIGRTMIN + 9, 181*842b42dfSAlex Bennée __SIGRTMIN + 10, 182*842b42dfSAlex Bennée __SIGRTMIN + 11, 183*842b42dfSAlex Bennée __SIGRTMIN + 12, 184*842b42dfSAlex Bennée __SIGRTMIN + 13, 185*842b42dfSAlex Bennée __SIGRTMIN + 14, 186*842b42dfSAlex Bennée __SIGRTMIN + 15, 187*842b42dfSAlex Bennée __SIGRTMIN + 16, 188*842b42dfSAlex Bennée __SIGRTMIN + 17, 189*842b42dfSAlex Bennée __SIGRTMIN + 18, 190*842b42dfSAlex Bennée __SIGRTMIN + 19, 191*842b42dfSAlex Bennée __SIGRTMIN + 20, 192*842b42dfSAlex Bennée __SIGRTMIN + 21, 193*842b42dfSAlex Bennée __SIGRTMIN + 22, 194*842b42dfSAlex Bennée __SIGRTMIN + 23, 195*842b42dfSAlex Bennée __SIGRTMIN + 24, 196*842b42dfSAlex Bennée __SIGRTMIN + 25, 197*842b42dfSAlex Bennée __SIGRTMIN + 26, 198*842b42dfSAlex Bennée __SIGRTMIN + 27, 199*842b42dfSAlex Bennée __SIGRTMIN + 28, 200*842b42dfSAlex Bennée __SIGRTMIN + 29, 201*842b42dfSAlex Bennée __SIGRTMIN + 30, 202*842b42dfSAlex Bennée __SIGRTMIN + 31, 203*842b42dfSAlex Bennée -1, /* SIGCANCEL */ 204*842b42dfSAlex Bennée __SIGRTMIN, 205*842b42dfSAlex Bennée __SIGRTMIN + 32, 206*842b42dfSAlex Bennée __SIGRTMIN + 33, 207*842b42dfSAlex Bennée __SIGRTMIN + 34, 208*842b42dfSAlex Bennée __SIGRTMIN + 35, 209*842b42dfSAlex Bennée __SIGRTMIN + 36, 210*842b42dfSAlex Bennée __SIGRTMIN + 37, 211*842b42dfSAlex Bennée __SIGRTMIN + 38, 212*842b42dfSAlex Bennée __SIGRTMIN + 39, 213*842b42dfSAlex Bennée __SIGRTMIN + 40, 214*842b42dfSAlex Bennée __SIGRTMIN + 41, 215*842b42dfSAlex Bennée __SIGRTMIN + 42, 216*842b42dfSAlex Bennée __SIGRTMIN + 43, 217*842b42dfSAlex Bennée __SIGRTMIN + 44, 218*842b42dfSAlex Bennée __SIGRTMIN + 45, 219*842b42dfSAlex Bennée __SIGRTMIN + 46, 220*842b42dfSAlex Bennée __SIGRTMIN + 47, 221*842b42dfSAlex Bennée __SIGRTMIN + 48, 222*842b42dfSAlex Bennée __SIGRTMIN + 49, 223*842b42dfSAlex Bennée __SIGRTMIN + 50, 224*842b42dfSAlex Bennée __SIGRTMIN + 51, 225*842b42dfSAlex Bennée __SIGRTMIN + 52, 226*842b42dfSAlex Bennée __SIGRTMIN + 53, 227*842b42dfSAlex Bennée __SIGRTMIN + 54, 228*842b42dfSAlex Bennée __SIGRTMIN + 55, 229*842b42dfSAlex Bennée __SIGRTMIN + 56, 230*842b42dfSAlex Bennée __SIGRTMIN + 57, 231*842b42dfSAlex Bennée __SIGRTMIN + 58, 232*842b42dfSAlex Bennée __SIGRTMIN + 59, 233*842b42dfSAlex Bennée __SIGRTMIN + 60, 234*842b42dfSAlex Bennée __SIGRTMIN + 61, 235*842b42dfSAlex Bennée __SIGRTMIN + 62, 236*842b42dfSAlex Bennée __SIGRTMIN + 63, 237*842b42dfSAlex Bennée __SIGRTMIN + 64, 238*842b42dfSAlex Bennée __SIGRTMIN + 65, 239*842b42dfSAlex Bennée __SIGRTMIN + 66, 240*842b42dfSAlex Bennée __SIGRTMIN + 67, 241*842b42dfSAlex Bennée __SIGRTMIN + 68, 242*842b42dfSAlex Bennée __SIGRTMIN + 69, 243*842b42dfSAlex Bennée __SIGRTMIN + 70, 244*842b42dfSAlex Bennée __SIGRTMIN + 71, 245*842b42dfSAlex Bennée __SIGRTMIN + 72, 246*842b42dfSAlex Bennée __SIGRTMIN + 73, 247*842b42dfSAlex Bennée __SIGRTMIN + 74, 248*842b42dfSAlex Bennée __SIGRTMIN + 75, 249*842b42dfSAlex Bennée __SIGRTMIN + 76, 250*842b42dfSAlex Bennée __SIGRTMIN + 77, 251*842b42dfSAlex Bennée __SIGRTMIN + 78, 252*842b42dfSAlex Bennée __SIGRTMIN + 79, 253*842b42dfSAlex Bennée __SIGRTMIN + 80, 254*842b42dfSAlex Bennée __SIGRTMIN + 81, 255*842b42dfSAlex Bennée __SIGRTMIN + 82, 256*842b42dfSAlex Bennée __SIGRTMIN + 83, 257*842b42dfSAlex Bennée __SIGRTMIN + 84, 258*842b42dfSAlex Bennée __SIGRTMIN + 85, 259*842b42dfSAlex Bennée __SIGRTMIN + 86, 260*842b42dfSAlex Bennée __SIGRTMIN + 87, 261*842b42dfSAlex Bennée __SIGRTMIN + 88, 262*842b42dfSAlex Bennée __SIGRTMIN + 89, 263*842b42dfSAlex Bennée __SIGRTMIN + 90, 264*842b42dfSAlex Bennée __SIGRTMIN + 91, 265*842b42dfSAlex Bennée __SIGRTMIN + 92, 266*842b42dfSAlex Bennée __SIGRTMIN + 93, 267*842b42dfSAlex Bennée __SIGRTMIN + 94, 268*842b42dfSAlex Bennée __SIGRTMIN + 95, 269*842b42dfSAlex Bennée -1, /* SIGINFO */ 270*842b42dfSAlex Bennée -1, /* UNKNOWN */ 271*842b42dfSAlex Bennée -1, /* DEFAULT */ 272*842b42dfSAlex Bennée -1, 273*842b42dfSAlex Bennée -1, 274*842b42dfSAlex Bennée -1, 275*842b42dfSAlex Bennée -1, 276*842b42dfSAlex Bennée -1, 277*842b42dfSAlex Bennée -1 278*842b42dfSAlex Bennée #endif 279*842b42dfSAlex Bennée }; 280*842b42dfSAlex Bennée #else 281*842b42dfSAlex Bennée /* In system mode we only need SIGINT and SIGTRAP; other signals 282*842b42dfSAlex Bennée are not yet supported. */ 283*842b42dfSAlex Bennée 284*842b42dfSAlex Bennée enum { 285*842b42dfSAlex Bennée TARGET_SIGINT = 2, 286*842b42dfSAlex Bennée TARGET_SIGTRAP = 5 287*842b42dfSAlex Bennée }; 288*842b42dfSAlex Bennée 289*842b42dfSAlex Bennée static int gdb_signal_table[] = { 290*842b42dfSAlex Bennée -1, 291*842b42dfSAlex Bennée -1, 292*842b42dfSAlex Bennée TARGET_SIGINT, 293*842b42dfSAlex Bennée -1, 294*842b42dfSAlex Bennée -1, 295*842b42dfSAlex Bennée TARGET_SIGTRAP 296*842b42dfSAlex Bennée }; 297*842b42dfSAlex Bennée #endif 298*842b42dfSAlex Bennée 299*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 300*842b42dfSAlex Bennée static int target_signal_to_gdb (int sig) 301*842b42dfSAlex Bennée { 302*842b42dfSAlex Bennée int i; 303*842b42dfSAlex Bennée for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++) 304*842b42dfSAlex Bennée if (gdb_signal_table[i] == sig) 305*842b42dfSAlex Bennée return i; 306*842b42dfSAlex Bennée return GDB_SIGNAL_UNKNOWN; 307*842b42dfSAlex Bennée } 308*842b42dfSAlex Bennée #endif 309*842b42dfSAlex Bennée 310*842b42dfSAlex Bennée static int gdb_signal_to_target (int sig) 311*842b42dfSAlex Bennée { 312*842b42dfSAlex Bennée if (sig < ARRAY_SIZE (gdb_signal_table)) 313*842b42dfSAlex Bennée return gdb_signal_table[sig]; 314*842b42dfSAlex Bennée else 315*842b42dfSAlex Bennée return -1; 316*842b42dfSAlex Bennée } 317*842b42dfSAlex Bennée 318*842b42dfSAlex Bennée typedef struct GDBRegisterState { 319*842b42dfSAlex Bennée int base_reg; 320*842b42dfSAlex Bennée int num_regs; 321*842b42dfSAlex Bennée gdb_get_reg_cb get_reg; 322*842b42dfSAlex Bennée gdb_set_reg_cb set_reg; 323*842b42dfSAlex Bennée const char *xml; 324*842b42dfSAlex Bennée struct GDBRegisterState *next; 325*842b42dfSAlex Bennée } GDBRegisterState; 326*842b42dfSAlex Bennée 327*842b42dfSAlex Bennée typedef struct GDBProcess { 328*842b42dfSAlex Bennée uint32_t pid; 329*842b42dfSAlex Bennée bool attached; 330*842b42dfSAlex Bennée 331*842b42dfSAlex Bennée char target_xml[1024]; 332*842b42dfSAlex Bennée } GDBProcess; 333*842b42dfSAlex Bennée 334*842b42dfSAlex Bennée enum RSState { 335*842b42dfSAlex Bennée RS_INACTIVE, 336*842b42dfSAlex Bennée RS_IDLE, 337*842b42dfSAlex Bennée RS_GETLINE, 338*842b42dfSAlex Bennée RS_GETLINE_ESC, 339*842b42dfSAlex Bennée RS_GETLINE_RLE, 340*842b42dfSAlex Bennée RS_CHKSUM1, 341*842b42dfSAlex Bennée RS_CHKSUM2, 342*842b42dfSAlex Bennée }; 343*842b42dfSAlex Bennée typedef struct GDBState { 344*842b42dfSAlex Bennée bool init; /* have we been initialised? */ 345*842b42dfSAlex Bennée CPUState *c_cpu; /* current CPU for step/continue ops */ 346*842b42dfSAlex Bennée CPUState *g_cpu; /* current CPU for other ops */ 347*842b42dfSAlex Bennée CPUState *query_cpu; /* for q{f|s}ThreadInfo */ 348*842b42dfSAlex Bennée enum RSState state; /* parsing state */ 349*842b42dfSAlex Bennée char line_buf[MAX_PACKET_LENGTH]; 350*842b42dfSAlex Bennée int line_buf_index; 351*842b42dfSAlex Bennée int line_sum; /* running checksum */ 352*842b42dfSAlex Bennée int line_csum; /* checksum at the end of the packet */ 353*842b42dfSAlex Bennée GByteArray *last_packet; 354*842b42dfSAlex Bennée int signal; 355*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 356*842b42dfSAlex Bennée int fd; 357*842b42dfSAlex Bennée char *socket_path; 358*842b42dfSAlex Bennée int running_state; 359*842b42dfSAlex Bennée #else 360*842b42dfSAlex Bennée CharBackend chr; 361*842b42dfSAlex Bennée Chardev *mon_chr; 362*842b42dfSAlex Bennée #endif 363*842b42dfSAlex Bennée bool multiprocess; 364*842b42dfSAlex Bennée GDBProcess *processes; 365*842b42dfSAlex Bennée int process_num; 366*842b42dfSAlex Bennée char syscall_buf[256]; 367*842b42dfSAlex Bennée gdb_syscall_complete_cb current_syscall_cb; 368*842b42dfSAlex Bennée GString *str_buf; 369*842b42dfSAlex Bennée GByteArray *mem_buf; 370*842b42dfSAlex Bennée int sstep_flags; 371*842b42dfSAlex Bennée int supported_sstep_flags; 372*842b42dfSAlex Bennée } GDBState; 373*842b42dfSAlex Bennée 374*842b42dfSAlex Bennée static GDBState gdbserver_state; 375*842b42dfSAlex Bennée 376*842b42dfSAlex Bennée static void init_gdbserver_state(void) 377*842b42dfSAlex Bennée { 378*842b42dfSAlex Bennée g_assert(!gdbserver_state.init); 379*842b42dfSAlex Bennée memset(&gdbserver_state, 0, sizeof(GDBState)); 380*842b42dfSAlex Bennée gdbserver_state.init = true; 381*842b42dfSAlex Bennée gdbserver_state.str_buf = g_string_new(NULL); 382*842b42dfSAlex Bennée gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH); 383*842b42dfSAlex Bennée gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4); 384*842b42dfSAlex Bennée 385*842b42dfSAlex Bennée /* 386*842b42dfSAlex Bennée * In replay mode all events will come from the log and can't be 387*842b42dfSAlex Bennée * suppressed otherwise we would break determinism. However as those 388*842b42dfSAlex Bennée * events are tied to the number of executed instructions we won't see 389*842b42dfSAlex Bennée * them occurring every time we single step. 390*842b42dfSAlex Bennée */ 391*842b42dfSAlex Bennée if (replay_mode != REPLAY_MODE_NONE) { 392*842b42dfSAlex Bennée gdbserver_state.supported_sstep_flags = SSTEP_ENABLE; 393*842b42dfSAlex Bennée } else if (kvm_enabled()) { 394*842b42dfSAlex Bennée gdbserver_state.supported_sstep_flags = kvm_get_supported_sstep_flags(); 395*842b42dfSAlex Bennée } else { 396*842b42dfSAlex Bennée gdbserver_state.supported_sstep_flags = 397*842b42dfSAlex Bennée SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER; 398*842b42dfSAlex Bennée } 399*842b42dfSAlex Bennée 400*842b42dfSAlex Bennée /* 401*842b42dfSAlex Bennée * By default use no IRQs and no timers while single stepping so as to 402*842b42dfSAlex Bennée * make single stepping like an ICE HW step. 403*842b42dfSAlex Bennée */ 404*842b42dfSAlex Bennée gdbserver_state.sstep_flags = SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER; 405*842b42dfSAlex Bennée gdbserver_state.sstep_flags &= gdbserver_state.supported_sstep_flags; 406*842b42dfSAlex Bennée 407*842b42dfSAlex Bennée } 408*842b42dfSAlex Bennée 409*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 410*842b42dfSAlex Bennée static void reset_gdbserver_state(void) 411*842b42dfSAlex Bennée { 412*842b42dfSAlex Bennée g_free(gdbserver_state.processes); 413*842b42dfSAlex Bennée gdbserver_state.processes = NULL; 414*842b42dfSAlex Bennée gdbserver_state.process_num = 0; 415*842b42dfSAlex Bennée } 416*842b42dfSAlex Bennée #endif 417*842b42dfSAlex Bennée 418*842b42dfSAlex Bennée bool gdb_has_xml; 419*842b42dfSAlex Bennée 420*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 421*842b42dfSAlex Bennée 422*842b42dfSAlex Bennée static int get_char(void) 423*842b42dfSAlex Bennée { 424*842b42dfSAlex Bennée uint8_t ch; 425*842b42dfSAlex Bennée int ret; 426*842b42dfSAlex Bennée 427*842b42dfSAlex Bennée for(;;) { 428*842b42dfSAlex Bennée ret = recv(gdbserver_state.fd, &ch, 1, 0); 429*842b42dfSAlex Bennée if (ret < 0) { 430*842b42dfSAlex Bennée if (errno == ECONNRESET) 431*842b42dfSAlex Bennée gdbserver_state.fd = -1; 432*842b42dfSAlex Bennée if (errno != EINTR) 433*842b42dfSAlex Bennée return -1; 434*842b42dfSAlex Bennée } else if (ret == 0) { 435*842b42dfSAlex Bennée close(gdbserver_state.fd); 436*842b42dfSAlex Bennée gdbserver_state.fd = -1; 437*842b42dfSAlex Bennée return -1; 438*842b42dfSAlex Bennée } else { 439*842b42dfSAlex Bennée break; 440*842b42dfSAlex Bennée } 441*842b42dfSAlex Bennée } 442*842b42dfSAlex Bennée return ch; 443*842b42dfSAlex Bennée } 444*842b42dfSAlex Bennée #endif 445*842b42dfSAlex Bennée 446*842b42dfSAlex Bennée /* 447*842b42dfSAlex Bennée * Return true if there is a GDB currently connected to the stub 448*842b42dfSAlex Bennée * and attached to a CPU 449*842b42dfSAlex Bennée */ 450*842b42dfSAlex Bennée static bool gdb_attached(void) 451*842b42dfSAlex Bennée { 452*842b42dfSAlex Bennée return gdbserver_state.init && gdbserver_state.c_cpu; 453*842b42dfSAlex Bennée } 454*842b42dfSAlex Bennée 455*842b42dfSAlex Bennée static enum { 456*842b42dfSAlex Bennée GDB_SYS_UNKNOWN, 457*842b42dfSAlex Bennée GDB_SYS_ENABLED, 458*842b42dfSAlex Bennée GDB_SYS_DISABLED, 459*842b42dfSAlex Bennée } gdb_syscall_mode; 460*842b42dfSAlex Bennée 461*842b42dfSAlex Bennée /* Decide if either remote gdb syscalls or native file IO should be used. */ 462*842b42dfSAlex Bennée int use_gdb_syscalls(void) 463*842b42dfSAlex Bennée { 464*842b42dfSAlex Bennée SemihostingTarget target = semihosting_get_target(); 465*842b42dfSAlex Bennée if (target == SEMIHOSTING_TARGET_NATIVE) { 466*842b42dfSAlex Bennée /* -semihosting-config target=native */ 467*842b42dfSAlex Bennée return false; 468*842b42dfSAlex Bennée } else if (target == SEMIHOSTING_TARGET_GDB) { 469*842b42dfSAlex Bennée /* -semihosting-config target=gdb */ 470*842b42dfSAlex Bennée return true; 471*842b42dfSAlex Bennée } 472*842b42dfSAlex Bennée 473*842b42dfSAlex Bennée /* -semihosting-config target=auto */ 474*842b42dfSAlex Bennée /* On the first call check if gdb is connected and remember. */ 475*842b42dfSAlex Bennée if (gdb_syscall_mode == GDB_SYS_UNKNOWN) { 476*842b42dfSAlex Bennée gdb_syscall_mode = gdb_attached() ? GDB_SYS_ENABLED : GDB_SYS_DISABLED; 477*842b42dfSAlex Bennée } 478*842b42dfSAlex Bennée return gdb_syscall_mode == GDB_SYS_ENABLED; 479*842b42dfSAlex Bennée } 480*842b42dfSAlex Bennée 481*842b42dfSAlex Bennée static bool stub_can_reverse(void) 482*842b42dfSAlex Bennée { 483*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 484*842b42dfSAlex Bennée return false; 485*842b42dfSAlex Bennée #else 486*842b42dfSAlex Bennée return replay_mode == REPLAY_MODE_PLAY; 487*842b42dfSAlex Bennée #endif 488*842b42dfSAlex Bennée } 489*842b42dfSAlex Bennée 490*842b42dfSAlex Bennée /* Resume execution. */ 491*842b42dfSAlex Bennée static inline void gdb_continue(void) 492*842b42dfSAlex Bennée { 493*842b42dfSAlex Bennée 494*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 495*842b42dfSAlex Bennée gdbserver_state.running_state = 1; 496*842b42dfSAlex Bennée trace_gdbstub_op_continue(); 497*842b42dfSAlex Bennée #else 498*842b42dfSAlex Bennée if (!runstate_needs_reset()) { 499*842b42dfSAlex Bennée trace_gdbstub_op_continue(); 500*842b42dfSAlex Bennée vm_start(); 501*842b42dfSAlex Bennée } 502*842b42dfSAlex Bennée #endif 503*842b42dfSAlex Bennée } 504*842b42dfSAlex Bennée 505*842b42dfSAlex Bennée /* 506*842b42dfSAlex Bennée * Resume execution, per CPU actions. For user-mode emulation it's 507*842b42dfSAlex Bennée * equivalent to gdb_continue. 508*842b42dfSAlex Bennée */ 509*842b42dfSAlex Bennée static int gdb_continue_partial(char *newstates) 510*842b42dfSAlex Bennée { 511*842b42dfSAlex Bennée CPUState *cpu; 512*842b42dfSAlex Bennée int res = 0; 513*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 514*842b42dfSAlex Bennée /* 515*842b42dfSAlex Bennée * This is not exactly accurate, but it's an improvement compared to the 516*842b42dfSAlex Bennée * previous situation, where only one CPU would be single-stepped. 517*842b42dfSAlex Bennée */ 518*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 519*842b42dfSAlex Bennée if (newstates[cpu->cpu_index] == 's') { 520*842b42dfSAlex Bennée trace_gdbstub_op_stepping(cpu->cpu_index); 521*842b42dfSAlex Bennée cpu_single_step(cpu, gdbserver_state.sstep_flags); 522*842b42dfSAlex Bennée } 523*842b42dfSAlex Bennée } 524*842b42dfSAlex Bennée gdbserver_state.running_state = 1; 525*842b42dfSAlex Bennée #else 526*842b42dfSAlex Bennée int flag = 0; 527*842b42dfSAlex Bennée 528*842b42dfSAlex Bennée if (!runstate_needs_reset()) { 529*842b42dfSAlex Bennée bool step_requested = false; 530*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 531*842b42dfSAlex Bennée if (newstates[cpu->cpu_index] == 's') { 532*842b42dfSAlex Bennée step_requested = true; 533*842b42dfSAlex Bennée break; 534*842b42dfSAlex Bennée } 535*842b42dfSAlex Bennée } 536*842b42dfSAlex Bennée 537*842b42dfSAlex Bennée if (vm_prepare_start(step_requested)) { 538*842b42dfSAlex Bennée return 0; 539*842b42dfSAlex Bennée } 540*842b42dfSAlex Bennée 541*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 542*842b42dfSAlex Bennée switch (newstates[cpu->cpu_index]) { 543*842b42dfSAlex Bennée case 0: 544*842b42dfSAlex Bennée case 1: 545*842b42dfSAlex Bennée break; /* nothing to do here */ 546*842b42dfSAlex Bennée case 's': 547*842b42dfSAlex Bennée trace_gdbstub_op_stepping(cpu->cpu_index); 548*842b42dfSAlex Bennée cpu_single_step(cpu, gdbserver_state.sstep_flags); 549*842b42dfSAlex Bennée cpu_resume(cpu); 550*842b42dfSAlex Bennée flag = 1; 551*842b42dfSAlex Bennée break; 552*842b42dfSAlex Bennée case 'c': 553*842b42dfSAlex Bennée trace_gdbstub_op_continue_cpu(cpu->cpu_index); 554*842b42dfSAlex Bennée cpu_resume(cpu); 555*842b42dfSAlex Bennée flag = 1; 556*842b42dfSAlex Bennée break; 557*842b42dfSAlex Bennée default: 558*842b42dfSAlex Bennée res = -1; 559*842b42dfSAlex Bennée break; 560*842b42dfSAlex Bennée } 561*842b42dfSAlex Bennée } 562*842b42dfSAlex Bennée } 563*842b42dfSAlex Bennée if (flag) { 564*842b42dfSAlex Bennée qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true); 565*842b42dfSAlex Bennée } 566*842b42dfSAlex Bennée #endif 567*842b42dfSAlex Bennée return res; 568*842b42dfSAlex Bennée } 569*842b42dfSAlex Bennée 570*842b42dfSAlex Bennée static void put_buffer(const uint8_t *buf, int len) 571*842b42dfSAlex Bennée { 572*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 573*842b42dfSAlex Bennée int ret; 574*842b42dfSAlex Bennée 575*842b42dfSAlex Bennée while (len > 0) { 576*842b42dfSAlex Bennée ret = send(gdbserver_state.fd, buf, len, 0); 577*842b42dfSAlex Bennée if (ret < 0) { 578*842b42dfSAlex Bennée if (errno != EINTR) 579*842b42dfSAlex Bennée return; 580*842b42dfSAlex Bennée } else { 581*842b42dfSAlex Bennée buf += ret; 582*842b42dfSAlex Bennée len -= ret; 583*842b42dfSAlex Bennée } 584*842b42dfSAlex Bennée } 585*842b42dfSAlex Bennée #else 586*842b42dfSAlex Bennée /* XXX this blocks entire thread. Rewrite to use 587*842b42dfSAlex Bennée * qemu_chr_fe_write and background I/O callbacks */ 588*842b42dfSAlex Bennée qemu_chr_fe_write_all(&gdbserver_state.chr, buf, len); 589*842b42dfSAlex Bennée #endif 590*842b42dfSAlex Bennée } 591*842b42dfSAlex Bennée 592*842b42dfSAlex Bennée static inline int fromhex(int v) 593*842b42dfSAlex Bennée { 594*842b42dfSAlex Bennée if (v >= '0' && v <= '9') 595*842b42dfSAlex Bennée return v - '0'; 596*842b42dfSAlex Bennée else if (v >= 'A' && v <= 'F') 597*842b42dfSAlex Bennée return v - 'A' + 10; 598*842b42dfSAlex Bennée else if (v >= 'a' && v <= 'f') 599*842b42dfSAlex Bennée return v - 'a' + 10; 600*842b42dfSAlex Bennée else 601*842b42dfSAlex Bennée return 0; 602*842b42dfSAlex Bennée } 603*842b42dfSAlex Bennée 604*842b42dfSAlex Bennée static inline int tohex(int v) 605*842b42dfSAlex Bennée { 606*842b42dfSAlex Bennée if (v < 10) 607*842b42dfSAlex Bennée return v + '0'; 608*842b42dfSAlex Bennée else 609*842b42dfSAlex Bennée return v - 10 + 'a'; 610*842b42dfSAlex Bennée } 611*842b42dfSAlex Bennée 612*842b42dfSAlex Bennée /* writes 2*len+1 bytes in buf */ 613*842b42dfSAlex Bennée static void memtohex(GString *buf, const uint8_t *mem, int len) 614*842b42dfSAlex Bennée { 615*842b42dfSAlex Bennée int i, c; 616*842b42dfSAlex Bennée for(i = 0; i < len; i++) { 617*842b42dfSAlex Bennée c = mem[i]; 618*842b42dfSAlex Bennée g_string_append_c(buf, tohex(c >> 4)); 619*842b42dfSAlex Bennée g_string_append_c(buf, tohex(c & 0xf)); 620*842b42dfSAlex Bennée } 621*842b42dfSAlex Bennée g_string_append_c(buf, '\0'); 622*842b42dfSAlex Bennée } 623*842b42dfSAlex Bennée 624*842b42dfSAlex Bennée static void hextomem(GByteArray *mem, const char *buf, int len) 625*842b42dfSAlex Bennée { 626*842b42dfSAlex Bennée int i; 627*842b42dfSAlex Bennée 628*842b42dfSAlex Bennée for(i = 0; i < len; i++) { 629*842b42dfSAlex Bennée guint8 byte = fromhex(buf[0]) << 4 | fromhex(buf[1]); 630*842b42dfSAlex Bennée g_byte_array_append(mem, &byte, 1); 631*842b42dfSAlex Bennée buf += 2; 632*842b42dfSAlex Bennée } 633*842b42dfSAlex Bennée } 634*842b42dfSAlex Bennée 635*842b42dfSAlex Bennée static void hexdump(const char *buf, int len, 636*842b42dfSAlex Bennée void (*trace_fn)(size_t ofs, char const *text)) 637*842b42dfSAlex Bennée { 638*842b42dfSAlex Bennée char line_buffer[3 * 16 + 4 + 16 + 1]; 639*842b42dfSAlex Bennée 640*842b42dfSAlex Bennée size_t i; 641*842b42dfSAlex Bennée for (i = 0; i < len || (i & 0xF); ++i) { 642*842b42dfSAlex Bennée size_t byte_ofs = i & 15; 643*842b42dfSAlex Bennée 644*842b42dfSAlex Bennée if (byte_ofs == 0) { 645*842b42dfSAlex Bennée memset(line_buffer, ' ', 3 * 16 + 4 + 16); 646*842b42dfSAlex Bennée line_buffer[3 * 16 + 4 + 16] = 0; 647*842b42dfSAlex Bennée } 648*842b42dfSAlex Bennée 649*842b42dfSAlex Bennée size_t col_group = (i >> 2) & 3; 650*842b42dfSAlex Bennée size_t hex_col = byte_ofs * 3 + col_group; 651*842b42dfSAlex Bennée size_t txt_col = 3 * 16 + 4 + byte_ofs; 652*842b42dfSAlex Bennée 653*842b42dfSAlex Bennée if (i < len) { 654*842b42dfSAlex Bennée char value = buf[i]; 655*842b42dfSAlex Bennée 656*842b42dfSAlex Bennée line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF); 657*842b42dfSAlex Bennée line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF); 658*842b42dfSAlex Bennée line_buffer[txt_col + 0] = (value >= ' ' && value < 127) 659*842b42dfSAlex Bennée ? value 660*842b42dfSAlex Bennée : '.'; 661*842b42dfSAlex Bennée } 662*842b42dfSAlex Bennée 663*842b42dfSAlex Bennée if (byte_ofs == 0xF) 664*842b42dfSAlex Bennée trace_fn(i & -16, line_buffer); 665*842b42dfSAlex Bennée } 666*842b42dfSAlex Bennée } 667*842b42dfSAlex Bennée 668*842b42dfSAlex Bennée /* return -1 if error, 0 if OK */ 669*842b42dfSAlex Bennée static int put_packet_binary(const char *buf, int len, bool dump) 670*842b42dfSAlex Bennée { 671*842b42dfSAlex Bennée int csum, i; 672*842b42dfSAlex Bennée uint8_t footer[3]; 673*842b42dfSAlex Bennée 674*842b42dfSAlex Bennée if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) { 675*842b42dfSAlex Bennée hexdump(buf, len, trace_gdbstub_io_binaryreply); 676*842b42dfSAlex Bennée } 677*842b42dfSAlex Bennée 678*842b42dfSAlex Bennée for(;;) { 679*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.last_packet, 0); 680*842b42dfSAlex Bennée g_byte_array_append(gdbserver_state.last_packet, 681*842b42dfSAlex Bennée (const uint8_t *) "$", 1); 682*842b42dfSAlex Bennée g_byte_array_append(gdbserver_state.last_packet, 683*842b42dfSAlex Bennée (const uint8_t *) buf, len); 684*842b42dfSAlex Bennée csum = 0; 685*842b42dfSAlex Bennée for(i = 0; i < len; i++) { 686*842b42dfSAlex Bennée csum += buf[i]; 687*842b42dfSAlex Bennée } 688*842b42dfSAlex Bennée footer[0] = '#'; 689*842b42dfSAlex Bennée footer[1] = tohex((csum >> 4) & 0xf); 690*842b42dfSAlex Bennée footer[2] = tohex((csum) & 0xf); 691*842b42dfSAlex Bennée g_byte_array_append(gdbserver_state.last_packet, footer, 3); 692*842b42dfSAlex Bennée 693*842b42dfSAlex Bennée put_buffer(gdbserver_state.last_packet->data, 694*842b42dfSAlex Bennée gdbserver_state.last_packet->len); 695*842b42dfSAlex Bennée 696*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 697*842b42dfSAlex Bennée i = get_char(); 698*842b42dfSAlex Bennée if (i < 0) 699*842b42dfSAlex Bennée return -1; 700*842b42dfSAlex Bennée if (i == '+') 701*842b42dfSAlex Bennée break; 702*842b42dfSAlex Bennée #else 703*842b42dfSAlex Bennée break; 704*842b42dfSAlex Bennée #endif 705*842b42dfSAlex Bennée } 706*842b42dfSAlex Bennée return 0; 707*842b42dfSAlex Bennée } 708*842b42dfSAlex Bennée 709*842b42dfSAlex Bennée /* return -1 if error, 0 if OK */ 710*842b42dfSAlex Bennée static int put_packet(const char *buf) 711*842b42dfSAlex Bennée { 712*842b42dfSAlex Bennée trace_gdbstub_io_reply(buf); 713*842b42dfSAlex Bennée 714*842b42dfSAlex Bennée return put_packet_binary(buf, strlen(buf), false); 715*842b42dfSAlex Bennée } 716*842b42dfSAlex Bennée 717*842b42dfSAlex Bennée static void put_strbuf(void) 718*842b42dfSAlex Bennée { 719*842b42dfSAlex Bennée put_packet(gdbserver_state.str_buf->str); 720*842b42dfSAlex Bennée } 721*842b42dfSAlex Bennée 722*842b42dfSAlex Bennée /* Encode data using the encoding for 'x' packets. */ 723*842b42dfSAlex Bennée static void memtox(GString *buf, const char *mem, int len) 724*842b42dfSAlex Bennée { 725*842b42dfSAlex Bennée char c; 726*842b42dfSAlex Bennée 727*842b42dfSAlex Bennée while (len--) { 728*842b42dfSAlex Bennée c = *(mem++); 729*842b42dfSAlex Bennée switch (c) { 730*842b42dfSAlex Bennée case '#': case '$': case '*': case '}': 731*842b42dfSAlex Bennée g_string_append_c(buf, '}'); 732*842b42dfSAlex Bennée g_string_append_c(buf, c ^ 0x20); 733*842b42dfSAlex Bennée break; 734*842b42dfSAlex Bennée default: 735*842b42dfSAlex Bennée g_string_append_c(buf, c); 736*842b42dfSAlex Bennée break; 737*842b42dfSAlex Bennée } 738*842b42dfSAlex Bennée } 739*842b42dfSAlex Bennée } 740*842b42dfSAlex Bennée 741*842b42dfSAlex Bennée static uint32_t gdb_get_cpu_pid(CPUState *cpu) 742*842b42dfSAlex Bennée { 743*842b42dfSAlex Bennée /* TODO: In user mode, we should use the task state PID */ 744*842b42dfSAlex Bennée if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) { 745*842b42dfSAlex Bennée /* Return the default process' PID */ 746*842b42dfSAlex Bennée int index = gdbserver_state.process_num - 1; 747*842b42dfSAlex Bennée return gdbserver_state.processes[index].pid; 748*842b42dfSAlex Bennée } 749*842b42dfSAlex Bennée return cpu->cluster_index + 1; 750*842b42dfSAlex Bennée } 751*842b42dfSAlex Bennée 752*842b42dfSAlex Bennée static GDBProcess *gdb_get_process(uint32_t pid) 753*842b42dfSAlex Bennée { 754*842b42dfSAlex Bennée int i; 755*842b42dfSAlex Bennée 756*842b42dfSAlex Bennée if (!pid) { 757*842b42dfSAlex Bennée /* 0 means any process, we take the first one */ 758*842b42dfSAlex Bennée return &gdbserver_state.processes[0]; 759*842b42dfSAlex Bennée } 760*842b42dfSAlex Bennée 761*842b42dfSAlex Bennée for (i = 0; i < gdbserver_state.process_num; i++) { 762*842b42dfSAlex Bennée if (gdbserver_state.processes[i].pid == pid) { 763*842b42dfSAlex Bennée return &gdbserver_state.processes[i]; 764*842b42dfSAlex Bennée } 765*842b42dfSAlex Bennée } 766*842b42dfSAlex Bennée 767*842b42dfSAlex Bennée return NULL; 768*842b42dfSAlex Bennée } 769*842b42dfSAlex Bennée 770*842b42dfSAlex Bennée static GDBProcess *gdb_get_cpu_process(CPUState *cpu) 771*842b42dfSAlex Bennée { 772*842b42dfSAlex Bennée return gdb_get_process(gdb_get_cpu_pid(cpu)); 773*842b42dfSAlex Bennée } 774*842b42dfSAlex Bennée 775*842b42dfSAlex Bennée static CPUState *find_cpu(uint32_t thread_id) 776*842b42dfSAlex Bennée { 777*842b42dfSAlex Bennée CPUState *cpu; 778*842b42dfSAlex Bennée 779*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 780*842b42dfSAlex Bennée if (cpu_gdb_index(cpu) == thread_id) { 781*842b42dfSAlex Bennée return cpu; 782*842b42dfSAlex Bennée } 783*842b42dfSAlex Bennée } 784*842b42dfSAlex Bennée 785*842b42dfSAlex Bennée return NULL; 786*842b42dfSAlex Bennée } 787*842b42dfSAlex Bennée 788*842b42dfSAlex Bennée static CPUState *get_first_cpu_in_process(GDBProcess *process) 789*842b42dfSAlex Bennée { 790*842b42dfSAlex Bennée CPUState *cpu; 791*842b42dfSAlex Bennée 792*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 793*842b42dfSAlex Bennée if (gdb_get_cpu_pid(cpu) == process->pid) { 794*842b42dfSAlex Bennée return cpu; 795*842b42dfSAlex Bennée } 796*842b42dfSAlex Bennée } 797*842b42dfSAlex Bennée 798*842b42dfSAlex Bennée return NULL; 799*842b42dfSAlex Bennée } 800*842b42dfSAlex Bennée 801*842b42dfSAlex Bennée static CPUState *gdb_next_cpu_in_process(CPUState *cpu) 802*842b42dfSAlex Bennée { 803*842b42dfSAlex Bennée uint32_t pid = gdb_get_cpu_pid(cpu); 804*842b42dfSAlex Bennée cpu = CPU_NEXT(cpu); 805*842b42dfSAlex Bennée 806*842b42dfSAlex Bennée while (cpu) { 807*842b42dfSAlex Bennée if (gdb_get_cpu_pid(cpu) == pid) { 808*842b42dfSAlex Bennée break; 809*842b42dfSAlex Bennée } 810*842b42dfSAlex Bennée 811*842b42dfSAlex Bennée cpu = CPU_NEXT(cpu); 812*842b42dfSAlex Bennée } 813*842b42dfSAlex Bennée 814*842b42dfSAlex Bennée return cpu; 815*842b42dfSAlex Bennée } 816*842b42dfSAlex Bennée 817*842b42dfSAlex Bennée /* Return the cpu following @cpu, while ignoring unattached processes. */ 818*842b42dfSAlex Bennée static CPUState *gdb_next_attached_cpu(CPUState *cpu) 819*842b42dfSAlex Bennée { 820*842b42dfSAlex Bennée cpu = CPU_NEXT(cpu); 821*842b42dfSAlex Bennée 822*842b42dfSAlex Bennée while (cpu) { 823*842b42dfSAlex Bennée if (gdb_get_cpu_process(cpu)->attached) { 824*842b42dfSAlex Bennée break; 825*842b42dfSAlex Bennée } 826*842b42dfSAlex Bennée 827*842b42dfSAlex Bennée cpu = CPU_NEXT(cpu); 828*842b42dfSAlex Bennée } 829*842b42dfSAlex Bennée 830*842b42dfSAlex Bennée return cpu; 831*842b42dfSAlex Bennée } 832*842b42dfSAlex Bennée 833*842b42dfSAlex Bennée /* Return the first attached cpu */ 834*842b42dfSAlex Bennée static CPUState *gdb_first_attached_cpu(void) 835*842b42dfSAlex Bennée { 836*842b42dfSAlex Bennée CPUState *cpu = first_cpu; 837*842b42dfSAlex Bennée GDBProcess *process = gdb_get_cpu_process(cpu); 838*842b42dfSAlex Bennée 839*842b42dfSAlex Bennée if (!process->attached) { 840*842b42dfSAlex Bennée return gdb_next_attached_cpu(cpu); 841*842b42dfSAlex Bennée } 842*842b42dfSAlex Bennée 843*842b42dfSAlex Bennée return cpu; 844*842b42dfSAlex Bennée } 845*842b42dfSAlex Bennée 846*842b42dfSAlex Bennée static CPUState *gdb_get_cpu(uint32_t pid, uint32_t tid) 847*842b42dfSAlex Bennée { 848*842b42dfSAlex Bennée GDBProcess *process; 849*842b42dfSAlex Bennée CPUState *cpu; 850*842b42dfSAlex Bennée 851*842b42dfSAlex Bennée if (!pid && !tid) { 852*842b42dfSAlex Bennée /* 0 means any process/thread, we take the first attached one */ 853*842b42dfSAlex Bennée return gdb_first_attached_cpu(); 854*842b42dfSAlex Bennée } else if (pid && !tid) { 855*842b42dfSAlex Bennée /* any thread in a specific process */ 856*842b42dfSAlex Bennée process = gdb_get_process(pid); 857*842b42dfSAlex Bennée 858*842b42dfSAlex Bennée if (process == NULL) { 859*842b42dfSAlex Bennée return NULL; 860*842b42dfSAlex Bennée } 861*842b42dfSAlex Bennée 862*842b42dfSAlex Bennée if (!process->attached) { 863*842b42dfSAlex Bennée return NULL; 864*842b42dfSAlex Bennée } 865*842b42dfSAlex Bennée 866*842b42dfSAlex Bennée return get_first_cpu_in_process(process); 867*842b42dfSAlex Bennée } else { 868*842b42dfSAlex Bennée /* a specific thread */ 869*842b42dfSAlex Bennée cpu = find_cpu(tid); 870*842b42dfSAlex Bennée 871*842b42dfSAlex Bennée if (cpu == NULL) { 872*842b42dfSAlex Bennée return NULL; 873*842b42dfSAlex Bennée } 874*842b42dfSAlex Bennée 875*842b42dfSAlex Bennée process = gdb_get_cpu_process(cpu); 876*842b42dfSAlex Bennée 877*842b42dfSAlex Bennée if (pid && process->pid != pid) { 878*842b42dfSAlex Bennée return NULL; 879*842b42dfSAlex Bennée } 880*842b42dfSAlex Bennée 881*842b42dfSAlex Bennée if (!process->attached) { 882*842b42dfSAlex Bennée return NULL; 883*842b42dfSAlex Bennée } 884*842b42dfSAlex Bennée 885*842b42dfSAlex Bennée return cpu; 886*842b42dfSAlex Bennée } 887*842b42dfSAlex Bennée } 888*842b42dfSAlex Bennée 889*842b42dfSAlex Bennée static const char *get_feature_xml(const char *p, const char **newp, 890*842b42dfSAlex Bennée GDBProcess *process) 891*842b42dfSAlex Bennée { 892*842b42dfSAlex Bennée size_t len; 893*842b42dfSAlex Bennée int i; 894*842b42dfSAlex Bennée const char *name; 895*842b42dfSAlex Bennée CPUState *cpu = get_first_cpu_in_process(process); 896*842b42dfSAlex Bennée CPUClass *cc = CPU_GET_CLASS(cpu); 897*842b42dfSAlex Bennée 898*842b42dfSAlex Bennée len = 0; 899*842b42dfSAlex Bennée while (p[len] && p[len] != ':') 900*842b42dfSAlex Bennée len++; 901*842b42dfSAlex Bennée *newp = p + len; 902*842b42dfSAlex Bennée 903*842b42dfSAlex Bennée name = NULL; 904*842b42dfSAlex Bennée if (strncmp(p, "target.xml", len) == 0) { 905*842b42dfSAlex Bennée char *buf = process->target_xml; 906*842b42dfSAlex Bennée const size_t buf_sz = sizeof(process->target_xml); 907*842b42dfSAlex Bennée 908*842b42dfSAlex Bennée /* Generate the XML description for this CPU. */ 909*842b42dfSAlex Bennée if (!buf[0]) { 910*842b42dfSAlex Bennée GDBRegisterState *r; 911*842b42dfSAlex Bennée 912*842b42dfSAlex Bennée pstrcat(buf, buf_sz, 913*842b42dfSAlex Bennée "<?xml version=\"1.0\"?>" 914*842b42dfSAlex Bennée "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">" 915*842b42dfSAlex Bennée "<target>"); 916*842b42dfSAlex Bennée if (cc->gdb_arch_name) { 917*842b42dfSAlex Bennée gchar *arch = cc->gdb_arch_name(cpu); 918*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "<architecture>"); 919*842b42dfSAlex Bennée pstrcat(buf, buf_sz, arch); 920*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "</architecture>"); 921*842b42dfSAlex Bennée g_free(arch); 922*842b42dfSAlex Bennée } 923*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "<xi:include href=\""); 924*842b42dfSAlex Bennée pstrcat(buf, buf_sz, cc->gdb_core_xml_file); 925*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "\"/>"); 926*842b42dfSAlex Bennée for (r = cpu->gdb_regs; r; r = r->next) { 927*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "<xi:include href=\""); 928*842b42dfSAlex Bennée pstrcat(buf, buf_sz, r->xml); 929*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "\"/>"); 930*842b42dfSAlex Bennée } 931*842b42dfSAlex Bennée pstrcat(buf, buf_sz, "</target>"); 932*842b42dfSAlex Bennée } 933*842b42dfSAlex Bennée return buf; 934*842b42dfSAlex Bennée } 935*842b42dfSAlex Bennée if (cc->gdb_get_dynamic_xml) { 936*842b42dfSAlex Bennée char *xmlname = g_strndup(p, len); 937*842b42dfSAlex Bennée const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname); 938*842b42dfSAlex Bennée 939*842b42dfSAlex Bennée g_free(xmlname); 940*842b42dfSAlex Bennée if (xml) { 941*842b42dfSAlex Bennée return xml; 942*842b42dfSAlex Bennée } 943*842b42dfSAlex Bennée } 944*842b42dfSAlex Bennée for (i = 0; ; i++) { 945*842b42dfSAlex Bennée name = xml_builtin[i][0]; 946*842b42dfSAlex Bennée if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len)) 947*842b42dfSAlex Bennée break; 948*842b42dfSAlex Bennée } 949*842b42dfSAlex Bennée return name ? xml_builtin[i][1] : NULL; 950*842b42dfSAlex Bennée } 951*842b42dfSAlex Bennée 952*842b42dfSAlex Bennée static int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg) 953*842b42dfSAlex Bennée { 954*842b42dfSAlex Bennée CPUClass *cc = CPU_GET_CLASS(cpu); 955*842b42dfSAlex Bennée CPUArchState *env = cpu->env_ptr; 956*842b42dfSAlex Bennée GDBRegisterState *r; 957*842b42dfSAlex Bennée 958*842b42dfSAlex Bennée if (reg < cc->gdb_num_core_regs) { 959*842b42dfSAlex Bennée return cc->gdb_read_register(cpu, buf, reg); 960*842b42dfSAlex Bennée } 961*842b42dfSAlex Bennée 962*842b42dfSAlex Bennée for (r = cpu->gdb_regs; r; r = r->next) { 963*842b42dfSAlex Bennée if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) { 964*842b42dfSAlex Bennée return r->get_reg(env, buf, reg - r->base_reg); 965*842b42dfSAlex Bennée } 966*842b42dfSAlex Bennée } 967*842b42dfSAlex Bennée return 0; 968*842b42dfSAlex Bennée } 969*842b42dfSAlex Bennée 970*842b42dfSAlex Bennée static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg) 971*842b42dfSAlex Bennée { 972*842b42dfSAlex Bennée CPUClass *cc = CPU_GET_CLASS(cpu); 973*842b42dfSAlex Bennée CPUArchState *env = cpu->env_ptr; 974*842b42dfSAlex Bennée GDBRegisterState *r; 975*842b42dfSAlex Bennée 976*842b42dfSAlex Bennée if (reg < cc->gdb_num_core_regs) { 977*842b42dfSAlex Bennée return cc->gdb_write_register(cpu, mem_buf, reg); 978*842b42dfSAlex Bennée } 979*842b42dfSAlex Bennée 980*842b42dfSAlex Bennée for (r = cpu->gdb_regs; r; r = r->next) { 981*842b42dfSAlex Bennée if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) { 982*842b42dfSAlex Bennée return r->set_reg(env, mem_buf, reg - r->base_reg); 983*842b42dfSAlex Bennée } 984*842b42dfSAlex Bennée } 985*842b42dfSAlex Bennée return 0; 986*842b42dfSAlex Bennée } 987*842b42dfSAlex Bennée 988*842b42dfSAlex Bennée /* Register a supplemental set of CPU registers. If g_pos is nonzero it 989*842b42dfSAlex Bennée specifies the first register number and these registers are included in 990*842b42dfSAlex Bennée a standard "g" packet. Direction is relative to gdb, i.e. get_reg is 991*842b42dfSAlex Bennée gdb reading a CPU register, and set_reg is gdb modifying a CPU register. 992*842b42dfSAlex Bennée */ 993*842b42dfSAlex Bennée 994*842b42dfSAlex Bennée void gdb_register_coprocessor(CPUState *cpu, 995*842b42dfSAlex Bennée gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg, 996*842b42dfSAlex Bennée int num_regs, const char *xml, int g_pos) 997*842b42dfSAlex Bennée { 998*842b42dfSAlex Bennée GDBRegisterState *s; 999*842b42dfSAlex Bennée GDBRegisterState **p; 1000*842b42dfSAlex Bennée 1001*842b42dfSAlex Bennée p = &cpu->gdb_regs; 1002*842b42dfSAlex Bennée while (*p) { 1003*842b42dfSAlex Bennée /* Check for duplicates. */ 1004*842b42dfSAlex Bennée if (strcmp((*p)->xml, xml) == 0) 1005*842b42dfSAlex Bennée return; 1006*842b42dfSAlex Bennée p = &(*p)->next; 1007*842b42dfSAlex Bennée } 1008*842b42dfSAlex Bennée 1009*842b42dfSAlex Bennée s = g_new0(GDBRegisterState, 1); 1010*842b42dfSAlex Bennée s->base_reg = cpu->gdb_num_regs; 1011*842b42dfSAlex Bennée s->num_regs = num_regs; 1012*842b42dfSAlex Bennée s->get_reg = get_reg; 1013*842b42dfSAlex Bennée s->set_reg = set_reg; 1014*842b42dfSAlex Bennée s->xml = xml; 1015*842b42dfSAlex Bennée 1016*842b42dfSAlex Bennée /* Add to end of list. */ 1017*842b42dfSAlex Bennée cpu->gdb_num_regs += num_regs; 1018*842b42dfSAlex Bennée *p = s; 1019*842b42dfSAlex Bennée if (g_pos) { 1020*842b42dfSAlex Bennée if (g_pos != s->base_reg) { 1021*842b42dfSAlex Bennée error_report("Error: Bad gdb register numbering for '%s', " 1022*842b42dfSAlex Bennée "expected %d got %d", xml, g_pos, s->base_reg); 1023*842b42dfSAlex Bennée } else { 1024*842b42dfSAlex Bennée cpu->gdb_num_g_regs = cpu->gdb_num_regs; 1025*842b42dfSAlex Bennée } 1026*842b42dfSAlex Bennée } 1027*842b42dfSAlex Bennée } 1028*842b42dfSAlex Bennée 1029*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 1030*842b42dfSAlex Bennée /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */ 1031*842b42dfSAlex Bennée static inline int xlat_gdb_type(CPUState *cpu, int gdbtype) 1032*842b42dfSAlex Bennée { 1033*842b42dfSAlex Bennée static const int xlat[] = { 1034*842b42dfSAlex Bennée [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE, 1035*842b42dfSAlex Bennée [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ, 1036*842b42dfSAlex Bennée [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS, 1037*842b42dfSAlex Bennée }; 1038*842b42dfSAlex Bennée 1039*842b42dfSAlex Bennée CPUClass *cc = CPU_GET_CLASS(cpu); 1040*842b42dfSAlex Bennée int cputype = xlat[gdbtype]; 1041*842b42dfSAlex Bennée 1042*842b42dfSAlex Bennée if (cc->gdb_stop_before_watchpoint) { 1043*842b42dfSAlex Bennée cputype |= BP_STOP_BEFORE_ACCESS; 1044*842b42dfSAlex Bennée } 1045*842b42dfSAlex Bennée return cputype; 1046*842b42dfSAlex Bennée } 1047*842b42dfSAlex Bennée #endif 1048*842b42dfSAlex Bennée 1049*842b42dfSAlex Bennée static int gdb_breakpoint_insert(int type, target_ulong addr, target_ulong len) 1050*842b42dfSAlex Bennée { 1051*842b42dfSAlex Bennée CPUState *cpu; 1052*842b42dfSAlex Bennée int err = 0; 1053*842b42dfSAlex Bennée 1054*842b42dfSAlex Bennée if (kvm_enabled()) { 1055*842b42dfSAlex Bennée return kvm_insert_breakpoint(gdbserver_state.c_cpu, addr, len, type); 1056*842b42dfSAlex Bennée } 1057*842b42dfSAlex Bennée 1058*842b42dfSAlex Bennée switch (type) { 1059*842b42dfSAlex Bennée case GDB_BREAKPOINT_SW: 1060*842b42dfSAlex Bennée case GDB_BREAKPOINT_HW: 1061*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1062*842b42dfSAlex Bennée err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL); 1063*842b42dfSAlex Bennée if (err) { 1064*842b42dfSAlex Bennée break; 1065*842b42dfSAlex Bennée } 1066*842b42dfSAlex Bennée } 1067*842b42dfSAlex Bennée return err; 1068*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 1069*842b42dfSAlex Bennée case GDB_WATCHPOINT_WRITE: 1070*842b42dfSAlex Bennée case GDB_WATCHPOINT_READ: 1071*842b42dfSAlex Bennée case GDB_WATCHPOINT_ACCESS: 1072*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1073*842b42dfSAlex Bennée err = cpu_watchpoint_insert(cpu, addr, len, 1074*842b42dfSAlex Bennée xlat_gdb_type(cpu, type), NULL); 1075*842b42dfSAlex Bennée if (err) { 1076*842b42dfSAlex Bennée break; 1077*842b42dfSAlex Bennée } 1078*842b42dfSAlex Bennée } 1079*842b42dfSAlex Bennée return err; 1080*842b42dfSAlex Bennée #endif 1081*842b42dfSAlex Bennée default: 1082*842b42dfSAlex Bennée return -ENOSYS; 1083*842b42dfSAlex Bennée } 1084*842b42dfSAlex Bennée } 1085*842b42dfSAlex Bennée 1086*842b42dfSAlex Bennée static int gdb_breakpoint_remove(int type, target_ulong addr, target_ulong len) 1087*842b42dfSAlex Bennée { 1088*842b42dfSAlex Bennée CPUState *cpu; 1089*842b42dfSAlex Bennée int err = 0; 1090*842b42dfSAlex Bennée 1091*842b42dfSAlex Bennée if (kvm_enabled()) { 1092*842b42dfSAlex Bennée return kvm_remove_breakpoint(gdbserver_state.c_cpu, addr, len, type); 1093*842b42dfSAlex Bennée } 1094*842b42dfSAlex Bennée 1095*842b42dfSAlex Bennée switch (type) { 1096*842b42dfSAlex Bennée case GDB_BREAKPOINT_SW: 1097*842b42dfSAlex Bennée case GDB_BREAKPOINT_HW: 1098*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1099*842b42dfSAlex Bennée err = cpu_breakpoint_remove(cpu, addr, BP_GDB); 1100*842b42dfSAlex Bennée if (err) { 1101*842b42dfSAlex Bennée break; 1102*842b42dfSAlex Bennée } 1103*842b42dfSAlex Bennée } 1104*842b42dfSAlex Bennée return err; 1105*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 1106*842b42dfSAlex Bennée case GDB_WATCHPOINT_WRITE: 1107*842b42dfSAlex Bennée case GDB_WATCHPOINT_READ: 1108*842b42dfSAlex Bennée case GDB_WATCHPOINT_ACCESS: 1109*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1110*842b42dfSAlex Bennée err = cpu_watchpoint_remove(cpu, addr, len, 1111*842b42dfSAlex Bennée xlat_gdb_type(cpu, type)); 1112*842b42dfSAlex Bennée if (err) 1113*842b42dfSAlex Bennée break; 1114*842b42dfSAlex Bennée } 1115*842b42dfSAlex Bennée return err; 1116*842b42dfSAlex Bennée #endif 1117*842b42dfSAlex Bennée default: 1118*842b42dfSAlex Bennée return -ENOSYS; 1119*842b42dfSAlex Bennée } 1120*842b42dfSAlex Bennée } 1121*842b42dfSAlex Bennée 1122*842b42dfSAlex Bennée static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu) 1123*842b42dfSAlex Bennée { 1124*842b42dfSAlex Bennée cpu_breakpoint_remove_all(cpu, BP_GDB); 1125*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 1126*842b42dfSAlex Bennée cpu_watchpoint_remove_all(cpu, BP_GDB); 1127*842b42dfSAlex Bennée #endif 1128*842b42dfSAlex Bennée } 1129*842b42dfSAlex Bennée 1130*842b42dfSAlex Bennée static void gdb_process_breakpoint_remove_all(GDBProcess *p) 1131*842b42dfSAlex Bennée { 1132*842b42dfSAlex Bennée CPUState *cpu = get_first_cpu_in_process(p); 1133*842b42dfSAlex Bennée 1134*842b42dfSAlex Bennée while (cpu) { 1135*842b42dfSAlex Bennée gdb_cpu_breakpoint_remove_all(cpu); 1136*842b42dfSAlex Bennée cpu = gdb_next_cpu_in_process(cpu); 1137*842b42dfSAlex Bennée } 1138*842b42dfSAlex Bennée } 1139*842b42dfSAlex Bennée 1140*842b42dfSAlex Bennée static void gdb_breakpoint_remove_all(void) 1141*842b42dfSAlex Bennée { 1142*842b42dfSAlex Bennée CPUState *cpu; 1143*842b42dfSAlex Bennée 1144*842b42dfSAlex Bennée if (kvm_enabled()) { 1145*842b42dfSAlex Bennée kvm_remove_all_breakpoints(gdbserver_state.c_cpu); 1146*842b42dfSAlex Bennée return; 1147*842b42dfSAlex Bennée } 1148*842b42dfSAlex Bennée 1149*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1150*842b42dfSAlex Bennée gdb_cpu_breakpoint_remove_all(cpu); 1151*842b42dfSAlex Bennée } 1152*842b42dfSAlex Bennée } 1153*842b42dfSAlex Bennée 1154*842b42dfSAlex Bennée static void gdb_set_cpu_pc(target_ulong pc) 1155*842b42dfSAlex Bennée { 1156*842b42dfSAlex Bennée CPUState *cpu = gdbserver_state.c_cpu; 1157*842b42dfSAlex Bennée 1158*842b42dfSAlex Bennée cpu_synchronize_state(cpu); 1159*842b42dfSAlex Bennée cpu_set_pc(cpu, pc); 1160*842b42dfSAlex Bennée } 1161*842b42dfSAlex Bennée 1162*842b42dfSAlex Bennée static void gdb_append_thread_id(CPUState *cpu, GString *buf) 1163*842b42dfSAlex Bennée { 1164*842b42dfSAlex Bennée if (gdbserver_state.multiprocess) { 1165*842b42dfSAlex Bennée g_string_append_printf(buf, "p%02x.%02x", 1166*842b42dfSAlex Bennée gdb_get_cpu_pid(cpu), cpu_gdb_index(cpu)); 1167*842b42dfSAlex Bennée } else { 1168*842b42dfSAlex Bennée g_string_append_printf(buf, "%02x", cpu_gdb_index(cpu)); 1169*842b42dfSAlex Bennée } 1170*842b42dfSAlex Bennée } 1171*842b42dfSAlex Bennée 1172*842b42dfSAlex Bennée typedef enum GDBThreadIdKind { 1173*842b42dfSAlex Bennée GDB_ONE_THREAD = 0, 1174*842b42dfSAlex Bennée GDB_ALL_THREADS, /* One process, all threads */ 1175*842b42dfSAlex Bennée GDB_ALL_PROCESSES, 1176*842b42dfSAlex Bennée GDB_READ_THREAD_ERR 1177*842b42dfSAlex Bennée } GDBThreadIdKind; 1178*842b42dfSAlex Bennée 1179*842b42dfSAlex Bennée static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf, 1180*842b42dfSAlex Bennée uint32_t *pid, uint32_t *tid) 1181*842b42dfSAlex Bennée { 1182*842b42dfSAlex Bennée unsigned long p, t; 1183*842b42dfSAlex Bennée int ret; 1184*842b42dfSAlex Bennée 1185*842b42dfSAlex Bennée if (*buf == 'p') { 1186*842b42dfSAlex Bennée buf++; 1187*842b42dfSAlex Bennée ret = qemu_strtoul(buf, &buf, 16, &p); 1188*842b42dfSAlex Bennée 1189*842b42dfSAlex Bennée if (ret) { 1190*842b42dfSAlex Bennée return GDB_READ_THREAD_ERR; 1191*842b42dfSAlex Bennée } 1192*842b42dfSAlex Bennée 1193*842b42dfSAlex Bennée /* Skip '.' */ 1194*842b42dfSAlex Bennée buf++; 1195*842b42dfSAlex Bennée } else { 1196*842b42dfSAlex Bennée p = 1; 1197*842b42dfSAlex Bennée } 1198*842b42dfSAlex Bennée 1199*842b42dfSAlex Bennée ret = qemu_strtoul(buf, &buf, 16, &t); 1200*842b42dfSAlex Bennée 1201*842b42dfSAlex Bennée if (ret) { 1202*842b42dfSAlex Bennée return GDB_READ_THREAD_ERR; 1203*842b42dfSAlex Bennée } 1204*842b42dfSAlex Bennée 1205*842b42dfSAlex Bennée *end_buf = buf; 1206*842b42dfSAlex Bennée 1207*842b42dfSAlex Bennée if (p == -1) { 1208*842b42dfSAlex Bennée return GDB_ALL_PROCESSES; 1209*842b42dfSAlex Bennée } 1210*842b42dfSAlex Bennée 1211*842b42dfSAlex Bennée if (pid) { 1212*842b42dfSAlex Bennée *pid = p; 1213*842b42dfSAlex Bennée } 1214*842b42dfSAlex Bennée 1215*842b42dfSAlex Bennée if (t == -1) { 1216*842b42dfSAlex Bennée return GDB_ALL_THREADS; 1217*842b42dfSAlex Bennée } 1218*842b42dfSAlex Bennée 1219*842b42dfSAlex Bennée if (tid) { 1220*842b42dfSAlex Bennée *tid = t; 1221*842b42dfSAlex Bennée } 1222*842b42dfSAlex Bennée 1223*842b42dfSAlex Bennée return GDB_ONE_THREAD; 1224*842b42dfSAlex Bennée } 1225*842b42dfSAlex Bennée 1226*842b42dfSAlex Bennée /** 1227*842b42dfSAlex Bennée * gdb_handle_vcont - Parses and handles a vCont packet. 1228*842b42dfSAlex Bennée * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is 1229*842b42dfSAlex Bennée * a format error, 0 on success. 1230*842b42dfSAlex Bennée */ 1231*842b42dfSAlex Bennée static int gdb_handle_vcont(const char *p) 1232*842b42dfSAlex Bennée { 1233*842b42dfSAlex Bennée int res, signal = 0; 1234*842b42dfSAlex Bennée char cur_action; 1235*842b42dfSAlex Bennée char *newstates; 1236*842b42dfSAlex Bennée unsigned long tmp; 1237*842b42dfSAlex Bennée uint32_t pid, tid; 1238*842b42dfSAlex Bennée GDBProcess *process; 1239*842b42dfSAlex Bennée CPUState *cpu; 1240*842b42dfSAlex Bennée GDBThreadIdKind kind; 1241*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 1242*842b42dfSAlex Bennée int max_cpus = 1; /* global variable max_cpus exists only in system mode */ 1243*842b42dfSAlex Bennée 1244*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1245*842b42dfSAlex Bennée max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus; 1246*842b42dfSAlex Bennée } 1247*842b42dfSAlex Bennée #else 1248*842b42dfSAlex Bennée MachineState *ms = MACHINE(qdev_get_machine()); 1249*842b42dfSAlex Bennée unsigned int max_cpus = ms->smp.max_cpus; 1250*842b42dfSAlex Bennée #endif 1251*842b42dfSAlex Bennée /* uninitialised CPUs stay 0 */ 1252*842b42dfSAlex Bennée newstates = g_new0(char, max_cpus); 1253*842b42dfSAlex Bennée 1254*842b42dfSAlex Bennée /* mark valid CPUs with 1 */ 1255*842b42dfSAlex Bennée CPU_FOREACH(cpu) { 1256*842b42dfSAlex Bennée newstates[cpu->cpu_index] = 1; 1257*842b42dfSAlex Bennée } 1258*842b42dfSAlex Bennée 1259*842b42dfSAlex Bennée /* 1260*842b42dfSAlex Bennée * res keeps track of what error we are returning, with -ENOTSUP meaning 1261*842b42dfSAlex Bennée * that the command is unknown or unsupported, thus returning an empty 1262*842b42dfSAlex Bennée * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid, 1263*842b42dfSAlex Bennée * or incorrect parameters passed. 1264*842b42dfSAlex Bennée */ 1265*842b42dfSAlex Bennée res = 0; 1266*842b42dfSAlex Bennée while (*p) { 1267*842b42dfSAlex Bennée if (*p++ != ';') { 1268*842b42dfSAlex Bennée res = -ENOTSUP; 1269*842b42dfSAlex Bennée goto out; 1270*842b42dfSAlex Bennée } 1271*842b42dfSAlex Bennée 1272*842b42dfSAlex Bennée cur_action = *p++; 1273*842b42dfSAlex Bennée if (cur_action == 'C' || cur_action == 'S') { 1274*842b42dfSAlex Bennée cur_action = qemu_tolower(cur_action); 1275*842b42dfSAlex Bennée res = qemu_strtoul(p, &p, 16, &tmp); 1276*842b42dfSAlex Bennée if (res) { 1277*842b42dfSAlex Bennée goto out; 1278*842b42dfSAlex Bennée } 1279*842b42dfSAlex Bennée signal = gdb_signal_to_target(tmp); 1280*842b42dfSAlex Bennée } else if (cur_action != 'c' && cur_action != 's') { 1281*842b42dfSAlex Bennée /* unknown/invalid/unsupported command */ 1282*842b42dfSAlex Bennée res = -ENOTSUP; 1283*842b42dfSAlex Bennée goto out; 1284*842b42dfSAlex Bennée } 1285*842b42dfSAlex Bennée 1286*842b42dfSAlex Bennée if (*p == '\0' || *p == ';') { 1287*842b42dfSAlex Bennée /* 1288*842b42dfSAlex Bennée * No thread specifier, action is on "all threads". The 1289*842b42dfSAlex Bennée * specification is unclear regarding the process to act on. We 1290*842b42dfSAlex Bennée * choose all processes. 1291*842b42dfSAlex Bennée */ 1292*842b42dfSAlex Bennée kind = GDB_ALL_PROCESSES; 1293*842b42dfSAlex Bennée } else if (*p++ == ':') { 1294*842b42dfSAlex Bennée kind = read_thread_id(p, &p, &pid, &tid); 1295*842b42dfSAlex Bennée } else { 1296*842b42dfSAlex Bennée res = -ENOTSUP; 1297*842b42dfSAlex Bennée goto out; 1298*842b42dfSAlex Bennée } 1299*842b42dfSAlex Bennée 1300*842b42dfSAlex Bennée switch (kind) { 1301*842b42dfSAlex Bennée case GDB_READ_THREAD_ERR: 1302*842b42dfSAlex Bennée res = -EINVAL; 1303*842b42dfSAlex Bennée goto out; 1304*842b42dfSAlex Bennée 1305*842b42dfSAlex Bennée case GDB_ALL_PROCESSES: 1306*842b42dfSAlex Bennée cpu = gdb_first_attached_cpu(); 1307*842b42dfSAlex Bennée while (cpu) { 1308*842b42dfSAlex Bennée if (newstates[cpu->cpu_index] == 1) { 1309*842b42dfSAlex Bennée newstates[cpu->cpu_index] = cur_action; 1310*842b42dfSAlex Bennée } 1311*842b42dfSAlex Bennée 1312*842b42dfSAlex Bennée cpu = gdb_next_attached_cpu(cpu); 1313*842b42dfSAlex Bennée } 1314*842b42dfSAlex Bennée break; 1315*842b42dfSAlex Bennée 1316*842b42dfSAlex Bennée case GDB_ALL_THREADS: 1317*842b42dfSAlex Bennée process = gdb_get_process(pid); 1318*842b42dfSAlex Bennée 1319*842b42dfSAlex Bennée if (!process->attached) { 1320*842b42dfSAlex Bennée res = -EINVAL; 1321*842b42dfSAlex Bennée goto out; 1322*842b42dfSAlex Bennée } 1323*842b42dfSAlex Bennée 1324*842b42dfSAlex Bennée cpu = get_first_cpu_in_process(process); 1325*842b42dfSAlex Bennée while (cpu) { 1326*842b42dfSAlex Bennée if (newstates[cpu->cpu_index] == 1) { 1327*842b42dfSAlex Bennée newstates[cpu->cpu_index] = cur_action; 1328*842b42dfSAlex Bennée } 1329*842b42dfSAlex Bennée 1330*842b42dfSAlex Bennée cpu = gdb_next_cpu_in_process(cpu); 1331*842b42dfSAlex Bennée } 1332*842b42dfSAlex Bennée break; 1333*842b42dfSAlex Bennée 1334*842b42dfSAlex Bennée case GDB_ONE_THREAD: 1335*842b42dfSAlex Bennée cpu = gdb_get_cpu(pid, tid); 1336*842b42dfSAlex Bennée 1337*842b42dfSAlex Bennée /* invalid CPU/thread specified */ 1338*842b42dfSAlex Bennée if (!cpu) { 1339*842b42dfSAlex Bennée res = -EINVAL; 1340*842b42dfSAlex Bennée goto out; 1341*842b42dfSAlex Bennée } 1342*842b42dfSAlex Bennée 1343*842b42dfSAlex Bennée /* only use if no previous match occourred */ 1344*842b42dfSAlex Bennée if (newstates[cpu->cpu_index] == 1) { 1345*842b42dfSAlex Bennée newstates[cpu->cpu_index] = cur_action; 1346*842b42dfSAlex Bennée } 1347*842b42dfSAlex Bennée break; 1348*842b42dfSAlex Bennée } 1349*842b42dfSAlex Bennée } 1350*842b42dfSAlex Bennée gdbserver_state.signal = signal; 1351*842b42dfSAlex Bennée gdb_continue_partial(newstates); 1352*842b42dfSAlex Bennée 1353*842b42dfSAlex Bennée out: 1354*842b42dfSAlex Bennée g_free(newstates); 1355*842b42dfSAlex Bennée 1356*842b42dfSAlex Bennée return res; 1357*842b42dfSAlex Bennée } 1358*842b42dfSAlex Bennée 1359*842b42dfSAlex Bennée typedef union GdbCmdVariant { 1360*842b42dfSAlex Bennée const char *data; 1361*842b42dfSAlex Bennée uint8_t opcode; 1362*842b42dfSAlex Bennée unsigned long val_ul; 1363*842b42dfSAlex Bennée unsigned long long val_ull; 1364*842b42dfSAlex Bennée struct { 1365*842b42dfSAlex Bennée GDBThreadIdKind kind; 1366*842b42dfSAlex Bennée uint32_t pid; 1367*842b42dfSAlex Bennée uint32_t tid; 1368*842b42dfSAlex Bennée } thread_id; 1369*842b42dfSAlex Bennée } GdbCmdVariant; 1370*842b42dfSAlex Bennée 1371*842b42dfSAlex Bennée #define get_param(p, i) (&g_array_index(p, GdbCmdVariant, i)) 1372*842b42dfSAlex Bennée 1373*842b42dfSAlex Bennée static const char *cmd_next_param(const char *param, const char delimiter) 1374*842b42dfSAlex Bennée { 1375*842b42dfSAlex Bennée static const char all_delimiters[] = ",;:="; 1376*842b42dfSAlex Bennée char curr_delimiters[2] = {0}; 1377*842b42dfSAlex Bennée const char *delimiters; 1378*842b42dfSAlex Bennée 1379*842b42dfSAlex Bennée if (delimiter == '?') { 1380*842b42dfSAlex Bennée delimiters = all_delimiters; 1381*842b42dfSAlex Bennée } else if (delimiter == '0') { 1382*842b42dfSAlex Bennée return strchr(param, '\0'); 1383*842b42dfSAlex Bennée } else if (delimiter == '.' && *param) { 1384*842b42dfSAlex Bennée return param + 1; 1385*842b42dfSAlex Bennée } else { 1386*842b42dfSAlex Bennée curr_delimiters[0] = delimiter; 1387*842b42dfSAlex Bennée delimiters = curr_delimiters; 1388*842b42dfSAlex Bennée } 1389*842b42dfSAlex Bennée 1390*842b42dfSAlex Bennée param += strcspn(param, delimiters); 1391*842b42dfSAlex Bennée if (*param) { 1392*842b42dfSAlex Bennée param++; 1393*842b42dfSAlex Bennée } 1394*842b42dfSAlex Bennée return param; 1395*842b42dfSAlex Bennée } 1396*842b42dfSAlex Bennée 1397*842b42dfSAlex Bennée static int cmd_parse_params(const char *data, const char *schema, 1398*842b42dfSAlex Bennée GArray *params) 1399*842b42dfSAlex Bennée { 1400*842b42dfSAlex Bennée const char *curr_schema, *curr_data; 1401*842b42dfSAlex Bennée 1402*842b42dfSAlex Bennée g_assert(schema); 1403*842b42dfSAlex Bennée g_assert(params->len == 0); 1404*842b42dfSAlex Bennée 1405*842b42dfSAlex Bennée curr_schema = schema; 1406*842b42dfSAlex Bennée curr_data = data; 1407*842b42dfSAlex Bennée while (curr_schema[0] && curr_schema[1] && *curr_data) { 1408*842b42dfSAlex Bennée GdbCmdVariant this_param; 1409*842b42dfSAlex Bennée 1410*842b42dfSAlex Bennée switch (curr_schema[0]) { 1411*842b42dfSAlex Bennée case 'l': 1412*842b42dfSAlex Bennée if (qemu_strtoul(curr_data, &curr_data, 16, 1413*842b42dfSAlex Bennée &this_param.val_ul)) { 1414*842b42dfSAlex Bennée return -EINVAL; 1415*842b42dfSAlex Bennée } 1416*842b42dfSAlex Bennée curr_data = cmd_next_param(curr_data, curr_schema[1]); 1417*842b42dfSAlex Bennée g_array_append_val(params, this_param); 1418*842b42dfSAlex Bennée break; 1419*842b42dfSAlex Bennée case 'L': 1420*842b42dfSAlex Bennée if (qemu_strtou64(curr_data, &curr_data, 16, 1421*842b42dfSAlex Bennée (uint64_t *)&this_param.val_ull)) { 1422*842b42dfSAlex Bennée return -EINVAL; 1423*842b42dfSAlex Bennée } 1424*842b42dfSAlex Bennée curr_data = cmd_next_param(curr_data, curr_schema[1]); 1425*842b42dfSAlex Bennée g_array_append_val(params, this_param); 1426*842b42dfSAlex Bennée break; 1427*842b42dfSAlex Bennée case 's': 1428*842b42dfSAlex Bennée this_param.data = curr_data; 1429*842b42dfSAlex Bennée curr_data = cmd_next_param(curr_data, curr_schema[1]); 1430*842b42dfSAlex Bennée g_array_append_val(params, this_param); 1431*842b42dfSAlex Bennée break; 1432*842b42dfSAlex Bennée case 'o': 1433*842b42dfSAlex Bennée this_param.opcode = *(uint8_t *)curr_data; 1434*842b42dfSAlex Bennée curr_data = cmd_next_param(curr_data, curr_schema[1]); 1435*842b42dfSAlex Bennée g_array_append_val(params, this_param); 1436*842b42dfSAlex Bennée break; 1437*842b42dfSAlex Bennée case 't': 1438*842b42dfSAlex Bennée this_param.thread_id.kind = 1439*842b42dfSAlex Bennée read_thread_id(curr_data, &curr_data, 1440*842b42dfSAlex Bennée &this_param.thread_id.pid, 1441*842b42dfSAlex Bennée &this_param.thread_id.tid); 1442*842b42dfSAlex Bennée curr_data = cmd_next_param(curr_data, curr_schema[1]); 1443*842b42dfSAlex Bennée g_array_append_val(params, this_param); 1444*842b42dfSAlex Bennée break; 1445*842b42dfSAlex Bennée case '?': 1446*842b42dfSAlex Bennée curr_data = cmd_next_param(curr_data, curr_schema[1]); 1447*842b42dfSAlex Bennée break; 1448*842b42dfSAlex Bennée default: 1449*842b42dfSAlex Bennée return -EINVAL; 1450*842b42dfSAlex Bennée } 1451*842b42dfSAlex Bennée curr_schema += 2; 1452*842b42dfSAlex Bennée } 1453*842b42dfSAlex Bennée 1454*842b42dfSAlex Bennée return 0; 1455*842b42dfSAlex Bennée } 1456*842b42dfSAlex Bennée 1457*842b42dfSAlex Bennée typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx); 1458*842b42dfSAlex Bennée 1459*842b42dfSAlex Bennée /* 1460*842b42dfSAlex Bennée * cmd_startswith -> cmd is compared using startswith 1461*842b42dfSAlex Bennée * 1462*842b42dfSAlex Bennée * 1463*842b42dfSAlex Bennée * schema definitions: 1464*842b42dfSAlex Bennée * Each schema parameter entry consists of 2 chars, 1465*842b42dfSAlex Bennée * the first char represents the parameter type handling 1466*842b42dfSAlex Bennée * the second char represents the delimiter for the next parameter 1467*842b42dfSAlex Bennée * 1468*842b42dfSAlex Bennée * Currently supported schema types: 1469*842b42dfSAlex Bennée * 'l' -> unsigned long (stored in .val_ul) 1470*842b42dfSAlex Bennée * 'L' -> unsigned long long (stored in .val_ull) 1471*842b42dfSAlex Bennée * 's' -> string (stored in .data) 1472*842b42dfSAlex Bennée * 'o' -> single char (stored in .opcode) 1473*842b42dfSAlex Bennée * 't' -> thread id (stored in .thread_id) 1474*842b42dfSAlex Bennée * '?' -> skip according to delimiter 1475*842b42dfSAlex Bennée * 1476*842b42dfSAlex Bennée * Currently supported delimiters: 1477*842b42dfSAlex Bennée * '?' -> Stop at any delimiter (",;:=\0") 1478*842b42dfSAlex Bennée * '0' -> Stop at "\0" 1479*842b42dfSAlex Bennée * '.' -> Skip 1 char unless reached "\0" 1480*842b42dfSAlex Bennée * Any other value is treated as the delimiter value itself 1481*842b42dfSAlex Bennée */ 1482*842b42dfSAlex Bennée typedef struct GdbCmdParseEntry { 1483*842b42dfSAlex Bennée GdbCmdHandler handler; 1484*842b42dfSAlex Bennée const char *cmd; 1485*842b42dfSAlex Bennée bool cmd_startswith; 1486*842b42dfSAlex Bennée const char *schema; 1487*842b42dfSAlex Bennée } GdbCmdParseEntry; 1488*842b42dfSAlex Bennée 1489*842b42dfSAlex Bennée static inline int startswith(const char *string, const char *pattern) 1490*842b42dfSAlex Bennée { 1491*842b42dfSAlex Bennée return !strncmp(string, pattern, strlen(pattern)); 1492*842b42dfSAlex Bennée } 1493*842b42dfSAlex Bennée 1494*842b42dfSAlex Bennée static int process_string_cmd(void *user_ctx, const char *data, 1495*842b42dfSAlex Bennée const GdbCmdParseEntry *cmds, int num_cmds) 1496*842b42dfSAlex Bennée { 1497*842b42dfSAlex Bennée int i; 1498*842b42dfSAlex Bennée g_autoptr(GArray) params = g_array_new(false, true, sizeof(GdbCmdVariant)); 1499*842b42dfSAlex Bennée 1500*842b42dfSAlex Bennée if (!cmds) { 1501*842b42dfSAlex Bennée return -1; 1502*842b42dfSAlex Bennée } 1503*842b42dfSAlex Bennée 1504*842b42dfSAlex Bennée for (i = 0; i < num_cmds; i++) { 1505*842b42dfSAlex Bennée const GdbCmdParseEntry *cmd = &cmds[i]; 1506*842b42dfSAlex Bennée g_assert(cmd->handler && cmd->cmd); 1507*842b42dfSAlex Bennée 1508*842b42dfSAlex Bennée if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) || 1509*842b42dfSAlex Bennée (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) { 1510*842b42dfSAlex Bennée continue; 1511*842b42dfSAlex Bennée } 1512*842b42dfSAlex Bennée 1513*842b42dfSAlex Bennée if (cmd->schema) { 1514*842b42dfSAlex Bennée if (cmd_parse_params(&data[strlen(cmd->cmd)], 1515*842b42dfSAlex Bennée cmd->schema, params)) { 1516*842b42dfSAlex Bennée return -1; 1517*842b42dfSAlex Bennée } 1518*842b42dfSAlex Bennée } 1519*842b42dfSAlex Bennée 1520*842b42dfSAlex Bennée cmd->handler(params, user_ctx); 1521*842b42dfSAlex Bennée return 0; 1522*842b42dfSAlex Bennée } 1523*842b42dfSAlex Bennée 1524*842b42dfSAlex Bennée return -1; 1525*842b42dfSAlex Bennée } 1526*842b42dfSAlex Bennée 1527*842b42dfSAlex Bennée static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd) 1528*842b42dfSAlex Bennée { 1529*842b42dfSAlex Bennée if (!data) { 1530*842b42dfSAlex Bennée return; 1531*842b42dfSAlex Bennée } 1532*842b42dfSAlex Bennée 1533*842b42dfSAlex Bennée g_string_set_size(gdbserver_state.str_buf, 0); 1534*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.mem_buf, 0); 1535*842b42dfSAlex Bennée 1536*842b42dfSAlex Bennée /* In case there was an error during the command parsing we must 1537*842b42dfSAlex Bennée * send a NULL packet to indicate the command is not supported */ 1538*842b42dfSAlex Bennée if (process_string_cmd(NULL, data, cmd, 1)) { 1539*842b42dfSAlex Bennée put_packet(""); 1540*842b42dfSAlex Bennée } 1541*842b42dfSAlex Bennée } 1542*842b42dfSAlex Bennée 1543*842b42dfSAlex Bennée static void handle_detach(GArray *params, void *user_ctx) 1544*842b42dfSAlex Bennée { 1545*842b42dfSAlex Bennée GDBProcess *process; 1546*842b42dfSAlex Bennée uint32_t pid = 1; 1547*842b42dfSAlex Bennée 1548*842b42dfSAlex Bennée if (gdbserver_state.multiprocess) { 1549*842b42dfSAlex Bennée if (!params->len) { 1550*842b42dfSAlex Bennée put_packet("E22"); 1551*842b42dfSAlex Bennée return; 1552*842b42dfSAlex Bennée } 1553*842b42dfSAlex Bennée 1554*842b42dfSAlex Bennée pid = get_param(params, 0)->val_ul; 1555*842b42dfSAlex Bennée } 1556*842b42dfSAlex Bennée 1557*842b42dfSAlex Bennée process = gdb_get_process(pid); 1558*842b42dfSAlex Bennée gdb_process_breakpoint_remove_all(process); 1559*842b42dfSAlex Bennée process->attached = false; 1560*842b42dfSAlex Bennée 1561*842b42dfSAlex Bennée if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) { 1562*842b42dfSAlex Bennée gdbserver_state.c_cpu = gdb_first_attached_cpu(); 1563*842b42dfSAlex Bennée } 1564*842b42dfSAlex Bennée 1565*842b42dfSAlex Bennée if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) { 1566*842b42dfSAlex Bennée gdbserver_state.g_cpu = gdb_first_attached_cpu(); 1567*842b42dfSAlex Bennée } 1568*842b42dfSAlex Bennée 1569*842b42dfSAlex Bennée if (!gdbserver_state.c_cpu) { 1570*842b42dfSAlex Bennée /* No more process attached */ 1571*842b42dfSAlex Bennée gdb_syscall_mode = GDB_SYS_DISABLED; 1572*842b42dfSAlex Bennée gdb_continue(); 1573*842b42dfSAlex Bennée } 1574*842b42dfSAlex Bennée put_packet("OK"); 1575*842b42dfSAlex Bennée } 1576*842b42dfSAlex Bennée 1577*842b42dfSAlex Bennée static void handle_thread_alive(GArray *params, void *user_ctx) 1578*842b42dfSAlex Bennée { 1579*842b42dfSAlex Bennée CPUState *cpu; 1580*842b42dfSAlex Bennée 1581*842b42dfSAlex Bennée if (!params->len) { 1582*842b42dfSAlex Bennée put_packet("E22"); 1583*842b42dfSAlex Bennée return; 1584*842b42dfSAlex Bennée } 1585*842b42dfSAlex Bennée 1586*842b42dfSAlex Bennée if (get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) { 1587*842b42dfSAlex Bennée put_packet("E22"); 1588*842b42dfSAlex Bennée return; 1589*842b42dfSAlex Bennée } 1590*842b42dfSAlex Bennée 1591*842b42dfSAlex Bennée cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid, 1592*842b42dfSAlex Bennée get_param(params, 0)->thread_id.tid); 1593*842b42dfSAlex Bennée if (!cpu) { 1594*842b42dfSAlex Bennée put_packet("E22"); 1595*842b42dfSAlex Bennée return; 1596*842b42dfSAlex Bennée } 1597*842b42dfSAlex Bennée 1598*842b42dfSAlex Bennée put_packet("OK"); 1599*842b42dfSAlex Bennée } 1600*842b42dfSAlex Bennée 1601*842b42dfSAlex Bennée static void handle_continue(GArray *params, void *user_ctx) 1602*842b42dfSAlex Bennée { 1603*842b42dfSAlex Bennée if (params->len) { 1604*842b42dfSAlex Bennée gdb_set_cpu_pc(get_param(params, 0)->val_ull); 1605*842b42dfSAlex Bennée } 1606*842b42dfSAlex Bennée 1607*842b42dfSAlex Bennée gdbserver_state.signal = 0; 1608*842b42dfSAlex Bennée gdb_continue(); 1609*842b42dfSAlex Bennée } 1610*842b42dfSAlex Bennée 1611*842b42dfSAlex Bennée static void handle_cont_with_sig(GArray *params, void *user_ctx) 1612*842b42dfSAlex Bennée { 1613*842b42dfSAlex Bennée unsigned long signal = 0; 1614*842b42dfSAlex Bennée 1615*842b42dfSAlex Bennée /* 1616*842b42dfSAlex Bennée * Note: C sig;[addr] is currently unsupported and we simply 1617*842b42dfSAlex Bennée * omit the addr parameter 1618*842b42dfSAlex Bennée */ 1619*842b42dfSAlex Bennée if (params->len) { 1620*842b42dfSAlex Bennée signal = get_param(params, 0)->val_ul; 1621*842b42dfSAlex Bennée } 1622*842b42dfSAlex Bennée 1623*842b42dfSAlex Bennée gdbserver_state.signal = gdb_signal_to_target(signal); 1624*842b42dfSAlex Bennée if (gdbserver_state.signal == -1) { 1625*842b42dfSAlex Bennée gdbserver_state.signal = 0; 1626*842b42dfSAlex Bennée } 1627*842b42dfSAlex Bennée gdb_continue(); 1628*842b42dfSAlex Bennée } 1629*842b42dfSAlex Bennée 1630*842b42dfSAlex Bennée static void handle_set_thread(GArray *params, void *user_ctx) 1631*842b42dfSAlex Bennée { 1632*842b42dfSAlex Bennée CPUState *cpu; 1633*842b42dfSAlex Bennée 1634*842b42dfSAlex Bennée if (params->len != 2) { 1635*842b42dfSAlex Bennée put_packet("E22"); 1636*842b42dfSAlex Bennée return; 1637*842b42dfSAlex Bennée } 1638*842b42dfSAlex Bennée 1639*842b42dfSAlex Bennée if (get_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) { 1640*842b42dfSAlex Bennée put_packet("E22"); 1641*842b42dfSAlex Bennée return; 1642*842b42dfSAlex Bennée } 1643*842b42dfSAlex Bennée 1644*842b42dfSAlex Bennée if (get_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) { 1645*842b42dfSAlex Bennée put_packet("OK"); 1646*842b42dfSAlex Bennée return; 1647*842b42dfSAlex Bennée } 1648*842b42dfSAlex Bennée 1649*842b42dfSAlex Bennée cpu = gdb_get_cpu(get_param(params, 1)->thread_id.pid, 1650*842b42dfSAlex Bennée get_param(params, 1)->thread_id.tid); 1651*842b42dfSAlex Bennée if (!cpu) { 1652*842b42dfSAlex Bennée put_packet("E22"); 1653*842b42dfSAlex Bennée return; 1654*842b42dfSAlex Bennée } 1655*842b42dfSAlex Bennée 1656*842b42dfSAlex Bennée /* 1657*842b42dfSAlex Bennée * Note: This command is deprecated and modern gdb's will be using the 1658*842b42dfSAlex Bennée * vCont command instead. 1659*842b42dfSAlex Bennée */ 1660*842b42dfSAlex Bennée switch (get_param(params, 0)->opcode) { 1661*842b42dfSAlex Bennée case 'c': 1662*842b42dfSAlex Bennée gdbserver_state.c_cpu = cpu; 1663*842b42dfSAlex Bennée put_packet("OK"); 1664*842b42dfSAlex Bennée break; 1665*842b42dfSAlex Bennée case 'g': 1666*842b42dfSAlex Bennée gdbserver_state.g_cpu = cpu; 1667*842b42dfSAlex Bennée put_packet("OK"); 1668*842b42dfSAlex Bennée break; 1669*842b42dfSAlex Bennée default: 1670*842b42dfSAlex Bennée put_packet("E22"); 1671*842b42dfSAlex Bennée break; 1672*842b42dfSAlex Bennée } 1673*842b42dfSAlex Bennée } 1674*842b42dfSAlex Bennée 1675*842b42dfSAlex Bennée static void handle_insert_bp(GArray *params, void *user_ctx) 1676*842b42dfSAlex Bennée { 1677*842b42dfSAlex Bennée int res; 1678*842b42dfSAlex Bennée 1679*842b42dfSAlex Bennée if (params->len != 3) { 1680*842b42dfSAlex Bennée put_packet("E22"); 1681*842b42dfSAlex Bennée return; 1682*842b42dfSAlex Bennée } 1683*842b42dfSAlex Bennée 1684*842b42dfSAlex Bennée res = gdb_breakpoint_insert(get_param(params, 0)->val_ul, 1685*842b42dfSAlex Bennée get_param(params, 1)->val_ull, 1686*842b42dfSAlex Bennée get_param(params, 2)->val_ull); 1687*842b42dfSAlex Bennée if (res >= 0) { 1688*842b42dfSAlex Bennée put_packet("OK"); 1689*842b42dfSAlex Bennée return; 1690*842b42dfSAlex Bennée } else if (res == -ENOSYS) { 1691*842b42dfSAlex Bennée put_packet(""); 1692*842b42dfSAlex Bennée return; 1693*842b42dfSAlex Bennée } 1694*842b42dfSAlex Bennée 1695*842b42dfSAlex Bennée put_packet("E22"); 1696*842b42dfSAlex Bennée } 1697*842b42dfSAlex Bennée 1698*842b42dfSAlex Bennée static void handle_remove_bp(GArray *params, void *user_ctx) 1699*842b42dfSAlex Bennée { 1700*842b42dfSAlex Bennée int res; 1701*842b42dfSAlex Bennée 1702*842b42dfSAlex Bennée if (params->len != 3) { 1703*842b42dfSAlex Bennée put_packet("E22"); 1704*842b42dfSAlex Bennée return; 1705*842b42dfSAlex Bennée } 1706*842b42dfSAlex Bennée 1707*842b42dfSAlex Bennée res = gdb_breakpoint_remove(get_param(params, 0)->val_ul, 1708*842b42dfSAlex Bennée get_param(params, 1)->val_ull, 1709*842b42dfSAlex Bennée get_param(params, 2)->val_ull); 1710*842b42dfSAlex Bennée if (res >= 0) { 1711*842b42dfSAlex Bennée put_packet("OK"); 1712*842b42dfSAlex Bennée return; 1713*842b42dfSAlex Bennée } else if (res == -ENOSYS) { 1714*842b42dfSAlex Bennée put_packet(""); 1715*842b42dfSAlex Bennée return; 1716*842b42dfSAlex Bennée } 1717*842b42dfSAlex Bennée 1718*842b42dfSAlex Bennée put_packet("E22"); 1719*842b42dfSAlex Bennée } 1720*842b42dfSAlex Bennée 1721*842b42dfSAlex Bennée /* 1722*842b42dfSAlex Bennée * handle_set/get_reg 1723*842b42dfSAlex Bennée * 1724*842b42dfSAlex Bennée * Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available. 1725*842b42dfSAlex Bennée * This works, but can be very slow. Anything new enough to understand 1726*842b42dfSAlex Bennée * XML also knows how to use this properly. However to use this we 1727*842b42dfSAlex Bennée * need to define a local XML file as well as be talking to a 1728*842b42dfSAlex Bennée * reasonably modern gdb. Responding with an empty packet will cause 1729*842b42dfSAlex Bennée * the remote gdb to fallback to older methods. 1730*842b42dfSAlex Bennée */ 1731*842b42dfSAlex Bennée 1732*842b42dfSAlex Bennée static void handle_set_reg(GArray *params, void *user_ctx) 1733*842b42dfSAlex Bennée { 1734*842b42dfSAlex Bennée int reg_size; 1735*842b42dfSAlex Bennée 1736*842b42dfSAlex Bennée if (!gdb_has_xml) { 1737*842b42dfSAlex Bennée put_packet(""); 1738*842b42dfSAlex Bennée return; 1739*842b42dfSAlex Bennée } 1740*842b42dfSAlex Bennée 1741*842b42dfSAlex Bennée if (params->len != 2) { 1742*842b42dfSAlex Bennée put_packet("E22"); 1743*842b42dfSAlex Bennée return; 1744*842b42dfSAlex Bennée } 1745*842b42dfSAlex Bennée 1746*842b42dfSAlex Bennée reg_size = strlen(get_param(params, 1)->data) / 2; 1747*842b42dfSAlex Bennée hextomem(gdbserver_state.mem_buf, get_param(params, 1)->data, reg_size); 1748*842b42dfSAlex Bennée gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data, 1749*842b42dfSAlex Bennée get_param(params, 0)->val_ull); 1750*842b42dfSAlex Bennée put_packet("OK"); 1751*842b42dfSAlex Bennée } 1752*842b42dfSAlex Bennée 1753*842b42dfSAlex Bennée static void handle_get_reg(GArray *params, void *user_ctx) 1754*842b42dfSAlex Bennée { 1755*842b42dfSAlex Bennée int reg_size; 1756*842b42dfSAlex Bennée 1757*842b42dfSAlex Bennée if (!gdb_has_xml) { 1758*842b42dfSAlex Bennée put_packet(""); 1759*842b42dfSAlex Bennée return; 1760*842b42dfSAlex Bennée } 1761*842b42dfSAlex Bennée 1762*842b42dfSAlex Bennée if (!params->len) { 1763*842b42dfSAlex Bennée put_packet("E14"); 1764*842b42dfSAlex Bennée return; 1765*842b42dfSAlex Bennée } 1766*842b42dfSAlex Bennée 1767*842b42dfSAlex Bennée reg_size = gdb_read_register(gdbserver_state.g_cpu, 1768*842b42dfSAlex Bennée gdbserver_state.mem_buf, 1769*842b42dfSAlex Bennée get_param(params, 0)->val_ull); 1770*842b42dfSAlex Bennée if (!reg_size) { 1771*842b42dfSAlex Bennée put_packet("E14"); 1772*842b42dfSAlex Bennée return; 1773*842b42dfSAlex Bennée } else { 1774*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.mem_buf, reg_size); 1775*842b42dfSAlex Bennée } 1776*842b42dfSAlex Bennée 1777*842b42dfSAlex Bennée memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, reg_size); 1778*842b42dfSAlex Bennée put_strbuf(); 1779*842b42dfSAlex Bennée } 1780*842b42dfSAlex Bennée 1781*842b42dfSAlex Bennée static void handle_write_mem(GArray *params, void *user_ctx) 1782*842b42dfSAlex Bennée { 1783*842b42dfSAlex Bennée if (params->len != 3) { 1784*842b42dfSAlex Bennée put_packet("E22"); 1785*842b42dfSAlex Bennée return; 1786*842b42dfSAlex Bennée } 1787*842b42dfSAlex Bennée 1788*842b42dfSAlex Bennée /* hextomem() reads 2*len bytes */ 1789*842b42dfSAlex Bennée if (get_param(params, 1)->val_ull > 1790*842b42dfSAlex Bennée strlen(get_param(params, 2)->data) / 2) { 1791*842b42dfSAlex Bennée put_packet("E22"); 1792*842b42dfSAlex Bennée return; 1793*842b42dfSAlex Bennée } 1794*842b42dfSAlex Bennée 1795*842b42dfSAlex Bennée hextomem(gdbserver_state.mem_buf, get_param(params, 2)->data, 1796*842b42dfSAlex Bennée get_param(params, 1)->val_ull); 1797*842b42dfSAlex Bennée if (target_memory_rw_debug(gdbserver_state.g_cpu, 1798*842b42dfSAlex Bennée get_param(params, 0)->val_ull, 1799*842b42dfSAlex Bennée gdbserver_state.mem_buf->data, 1800*842b42dfSAlex Bennée gdbserver_state.mem_buf->len, true)) { 1801*842b42dfSAlex Bennée put_packet("E14"); 1802*842b42dfSAlex Bennée return; 1803*842b42dfSAlex Bennée } 1804*842b42dfSAlex Bennée 1805*842b42dfSAlex Bennée put_packet("OK"); 1806*842b42dfSAlex Bennée } 1807*842b42dfSAlex Bennée 1808*842b42dfSAlex Bennée static void handle_read_mem(GArray *params, void *user_ctx) 1809*842b42dfSAlex Bennée { 1810*842b42dfSAlex Bennée if (params->len != 2) { 1811*842b42dfSAlex Bennée put_packet("E22"); 1812*842b42dfSAlex Bennée return; 1813*842b42dfSAlex Bennée } 1814*842b42dfSAlex Bennée 1815*842b42dfSAlex Bennée /* memtohex() doubles the required space */ 1816*842b42dfSAlex Bennée if (get_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) { 1817*842b42dfSAlex Bennée put_packet("E22"); 1818*842b42dfSAlex Bennée return; 1819*842b42dfSAlex Bennée } 1820*842b42dfSAlex Bennée 1821*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.mem_buf, 1822*842b42dfSAlex Bennée get_param(params, 1)->val_ull); 1823*842b42dfSAlex Bennée 1824*842b42dfSAlex Bennée if (target_memory_rw_debug(gdbserver_state.g_cpu, 1825*842b42dfSAlex Bennée get_param(params, 0)->val_ull, 1826*842b42dfSAlex Bennée gdbserver_state.mem_buf->data, 1827*842b42dfSAlex Bennée gdbserver_state.mem_buf->len, false)) { 1828*842b42dfSAlex Bennée put_packet("E14"); 1829*842b42dfSAlex Bennée return; 1830*842b42dfSAlex Bennée } 1831*842b42dfSAlex Bennée 1832*842b42dfSAlex Bennée memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, 1833*842b42dfSAlex Bennée gdbserver_state.mem_buf->len); 1834*842b42dfSAlex Bennée put_strbuf(); 1835*842b42dfSAlex Bennée } 1836*842b42dfSAlex Bennée 1837*842b42dfSAlex Bennée static void handle_write_all_regs(GArray *params, void *user_ctx) 1838*842b42dfSAlex Bennée { 1839*842b42dfSAlex Bennée target_ulong addr, len; 1840*842b42dfSAlex Bennée uint8_t *registers; 1841*842b42dfSAlex Bennée int reg_size; 1842*842b42dfSAlex Bennée 1843*842b42dfSAlex Bennée if (!params->len) { 1844*842b42dfSAlex Bennée return; 1845*842b42dfSAlex Bennée } 1846*842b42dfSAlex Bennée 1847*842b42dfSAlex Bennée cpu_synchronize_state(gdbserver_state.g_cpu); 1848*842b42dfSAlex Bennée len = strlen(get_param(params, 0)->data) / 2; 1849*842b42dfSAlex Bennée hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len); 1850*842b42dfSAlex Bennée registers = gdbserver_state.mem_buf->data; 1851*842b42dfSAlex Bennée for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0; 1852*842b42dfSAlex Bennée addr++) { 1853*842b42dfSAlex Bennée reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, addr); 1854*842b42dfSAlex Bennée len -= reg_size; 1855*842b42dfSAlex Bennée registers += reg_size; 1856*842b42dfSAlex Bennée } 1857*842b42dfSAlex Bennée put_packet("OK"); 1858*842b42dfSAlex Bennée } 1859*842b42dfSAlex Bennée 1860*842b42dfSAlex Bennée static void handle_read_all_regs(GArray *params, void *user_ctx) 1861*842b42dfSAlex Bennée { 1862*842b42dfSAlex Bennée target_ulong addr, len; 1863*842b42dfSAlex Bennée 1864*842b42dfSAlex Bennée cpu_synchronize_state(gdbserver_state.g_cpu); 1865*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.mem_buf, 0); 1866*842b42dfSAlex Bennée len = 0; 1867*842b42dfSAlex Bennée for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs; addr++) { 1868*842b42dfSAlex Bennée len += gdb_read_register(gdbserver_state.g_cpu, 1869*842b42dfSAlex Bennée gdbserver_state.mem_buf, 1870*842b42dfSAlex Bennée addr); 1871*842b42dfSAlex Bennée } 1872*842b42dfSAlex Bennée g_assert(len == gdbserver_state.mem_buf->len); 1873*842b42dfSAlex Bennée 1874*842b42dfSAlex Bennée memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len); 1875*842b42dfSAlex Bennée put_strbuf(); 1876*842b42dfSAlex Bennée } 1877*842b42dfSAlex Bennée 1878*842b42dfSAlex Bennée static void handle_file_io(GArray *params, void *user_ctx) 1879*842b42dfSAlex Bennée { 1880*842b42dfSAlex Bennée if (params->len >= 1 && gdbserver_state.current_syscall_cb) { 1881*842b42dfSAlex Bennée uint64_t ret; 1882*842b42dfSAlex Bennée int err; 1883*842b42dfSAlex Bennée 1884*842b42dfSAlex Bennée ret = get_param(params, 0)->val_ull; 1885*842b42dfSAlex Bennée if (params->len >= 2) { 1886*842b42dfSAlex Bennée err = get_param(params, 1)->val_ull; 1887*842b42dfSAlex Bennée } else { 1888*842b42dfSAlex Bennée err = 0; 1889*842b42dfSAlex Bennée } 1890*842b42dfSAlex Bennée 1891*842b42dfSAlex Bennée /* Convert GDB error numbers back to host error numbers. */ 1892*842b42dfSAlex Bennée #define E(X) case GDB_E##X: err = E##X; break 1893*842b42dfSAlex Bennée switch (err) { 1894*842b42dfSAlex Bennée case 0: 1895*842b42dfSAlex Bennée break; 1896*842b42dfSAlex Bennée E(PERM); 1897*842b42dfSAlex Bennée E(NOENT); 1898*842b42dfSAlex Bennée E(INTR); 1899*842b42dfSAlex Bennée E(BADF); 1900*842b42dfSAlex Bennée E(ACCES); 1901*842b42dfSAlex Bennée E(FAULT); 1902*842b42dfSAlex Bennée E(BUSY); 1903*842b42dfSAlex Bennée E(EXIST); 1904*842b42dfSAlex Bennée E(NODEV); 1905*842b42dfSAlex Bennée E(NOTDIR); 1906*842b42dfSAlex Bennée E(ISDIR); 1907*842b42dfSAlex Bennée E(INVAL); 1908*842b42dfSAlex Bennée E(NFILE); 1909*842b42dfSAlex Bennée E(MFILE); 1910*842b42dfSAlex Bennée E(FBIG); 1911*842b42dfSAlex Bennée E(NOSPC); 1912*842b42dfSAlex Bennée E(SPIPE); 1913*842b42dfSAlex Bennée E(ROFS); 1914*842b42dfSAlex Bennée E(NAMETOOLONG); 1915*842b42dfSAlex Bennée default: 1916*842b42dfSAlex Bennée err = EINVAL; 1917*842b42dfSAlex Bennée break; 1918*842b42dfSAlex Bennée } 1919*842b42dfSAlex Bennée #undef E 1920*842b42dfSAlex Bennée 1921*842b42dfSAlex Bennée gdbserver_state.current_syscall_cb(gdbserver_state.c_cpu, ret, err); 1922*842b42dfSAlex Bennée gdbserver_state.current_syscall_cb = NULL; 1923*842b42dfSAlex Bennée } 1924*842b42dfSAlex Bennée 1925*842b42dfSAlex Bennée if (params->len >= 3 && get_param(params, 2)->opcode == (uint8_t)'C') { 1926*842b42dfSAlex Bennée put_packet("T02"); 1927*842b42dfSAlex Bennée return; 1928*842b42dfSAlex Bennée } 1929*842b42dfSAlex Bennée 1930*842b42dfSAlex Bennée gdb_continue(); 1931*842b42dfSAlex Bennée } 1932*842b42dfSAlex Bennée 1933*842b42dfSAlex Bennée static void handle_step(GArray *params, void *user_ctx) 1934*842b42dfSAlex Bennée { 1935*842b42dfSAlex Bennée if (params->len) { 1936*842b42dfSAlex Bennée gdb_set_cpu_pc((target_ulong)get_param(params, 0)->val_ull); 1937*842b42dfSAlex Bennée } 1938*842b42dfSAlex Bennée 1939*842b42dfSAlex Bennée cpu_single_step(gdbserver_state.c_cpu, gdbserver_state.sstep_flags); 1940*842b42dfSAlex Bennée gdb_continue(); 1941*842b42dfSAlex Bennée } 1942*842b42dfSAlex Bennée 1943*842b42dfSAlex Bennée static void handle_backward(GArray *params, void *user_ctx) 1944*842b42dfSAlex Bennée { 1945*842b42dfSAlex Bennée if (!stub_can_reverse()) { 1946*842b42dfSAlex Bennée put_packet("E22"); 1947*842b42dfSAlex Bennée } 1948*842b42dfSAlex Bennée if (params->len == 1) { 1949*842b42dfSAlex Bennée switch (get_param(params, 0)->opcode) { 1950*842b42dfSAlex Bennée case 's': 1951*842b42dfSAlex Bennée if (replay_reverse_step()) { 1952*842b42dfSAlex Bennée gdb_continue(); 1953*842b42dfSAlex Bennée } else { 1954*842b42dfSAlex Bennée put_packet("E14"); 1955*842b42dfSAlex Bennée } 1956*842b42dfSAlex Bennée return; 1957*842b42dfSAlex Bennée case 'c': 1958*842b42dfSAlex Bennée if (replay_reverse_continue()) { 1959*842b42dfSAlex Bennée gdb_continue(); 1960*842b42dfSAlex Bennée } else { 1961*842b42dfSAlex Bennée put_packet("E14"); 1962*842b42dfSAlex Bennée } 1963*842b42dfSAlex Bennée return; 1964*842b42dfSAlex Bennée } 1965*842b42dfSAlex Bennée } 1966*842b42dfSAlex Bennée 1967*842b42dfSAlex Bennée /* Default invalid command */ 1968*842b42dfSAlex Bennée put_packet(""); 1969*842b42dfSAlex Bennée } 1970*842b42dfSAlex Bennée 1971*842b42dfSAlex Bennée static void handle_v_cont_query(GArray *params, void *user_ctx) 1972*842b42dfSAlex Bennée { 1973*842b42dfSAlex Bennée put_packet("vCont;c;C;s;S"); 1974*842b42dfSAlex Bennée } 1975*842b42dfSAlex Bennée 1976*842b42dfSAlex Bennée static void handle_v_cont(GArray *params, void *user_ctx) 1977*842b42dfSAlex Bennée { 1978*842b42dfSAlex Bennée int res; 1979*842b42dfSAlex Bennée 1980*842b42dfSAlex Bennée if (!params->len) { 1981*842b42dfSAlex Bennée return; 1982*842b42dfSAlex Bennée } 1983*842b42dfSAlex Bennée 1984*842b42dfSAlex Bennée res = gdb_handle_vcont(get_param(params, 0)->data); 1985*842b42dfSAlex Bennée if ((res == -EINVAL) || (res == -ERANGE)) { 1986*842b42dfSAlex Bennée put_packet("E22"); 1987*842b42dfSAlex Bennée } else if (res) { 1988*842b42dfSAlex Bennée put_packet(""); 1989*842b42dfSAlex Bennée } 1990*842b42dfSAlex Bennée } 1991*842b42dfSAlex Bennée 1992*842b42dfSAlex Bennée static void handle_v_attach(GArray *params, void *user_ctx) 1993*842b42dfSAlex Bennée { 1994*842b42dfSAlex Bennée GDBProcess *process; 1995*842b42dfSAlex Bennée CPUState *cpu; 1996*842b42dfSAlex Bennée 1997*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "E22"); 1998*842b42dfSAlex Bennée if (!params->len) { 1999*842b42dfSAlex Bennée goto cleanup; 2000*842b42dfSAlex Bennée } 2001*842b42dfSAlex Bennée 2002*842b42dfSAlex Bennée process = gdb_get_process(get_param(params, 0)->val_ul); 2003*842b42dfSAlex Bennée if (!process) { 2004*842b42dfSAlex Bennée goto cleanup; 2005*842b42dfSAlex Bennée } 2006*842b42dfSAlex Bennée 2007*842b42dfSAlex Bennée cpu = get_first_cpu_in_process(process); 2008*842b42dfSAlex Bennée if (!cpu) { 2009*842b42dfSAlex Bennée goto cleanup; 2010*842b42dfSAlex Bennée } 2011*842b42dfSAlex Bennée 2012*842b42dfSAlex Bennée process->attached = true; 2013*842b42dfSAlex Bennée gdbserver_state.g_cpu = cpu; 2014*842b42dfSAlex Bennée gdbserver_state.c_cpu = cpu; 2015*842b42dfSAlex Bennée 2016*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP); 2017*842b42dfSAlex Bennée gdb_append_thread_id(cpu, gdbserver_state.str_buf); 2018*842b42dfSAlex Bennée g_string_append_c(gdbserver_state.str_buf, ';'); 2019*842b42dfSAlex Bennée cleanup: 2020*842b42dfSAlex Bennée put_strbuf(); 2021*842b42dfSAlex Bennée } 2022*842b42dfSAlex Bennée 2023*842b42dfSAlex Bennée static void handle_v_kill(GArray *params, void *user_ctx) 2024*842b42dfSAlex Bennée { 2025*842b42dfSAlex Bennée /* Kill the target */ 2026*842b42dfSAlex Bennée put_packet("OK"); 2027*842b42dfSAlex Bennée error_report("QEMU: Terminated via GDBstub"); 2028*842b42dfSAlex Bennée gdb_exit(0); 2029*842b42dfSAlex Bennée exit(0); 2030*842b42dfSAlex Bennée } 2031*842b42dfSAlex Bennée 2032*842b42dfSAlex Bennée static const GdbCmdParseEntry gdb_v_commands_table[] = { 2033*842b42dfSAlex Bennée /* Order is important if has same prefix */ 2034*842b42dfSAlex Bennée { 2035*842b42dfSAlex Bennée .handler = handle_v_cont_query, 2036*842b42dfSAlex Bennée .cmd = "Cont?", 2037*842b42dfSAlex Bennée .cmd_startswith = 1 2038*842b42dfSAlex Bennée }, 2039*842b42dfSAlex Bennée { 2040*842b42dfSAlex Bennée .handler = handle_v_cont, 2041*842b42dfSAlex Bennée .cmd = "Cont", 2042*842b42dfSAlex Bennée .cmd_startswith = 1, 2043*842b42dfSAlex Bennée .schema = "s0" 2044*842b42dfSAlex Bennée }, 2045*842b42dfSAlex Bennée { 2046*842b42dfSAlex Bennée .handler = handle_v_attach, 2047*842b42dfSAlex Bennée .cmd = "Attach;", 2048*842b42dfSAlex Bennée .cmd_startswith = 1, 2049*842b42dfSAlex Bennée .schema = "l0" 2050*842b42dfSAlex Bennée }, 2051*842b42dfSAlex Bennée { 2052*842b42dfSAlex Bennée .handler = handle_v_kill, 2053*842b42dfSAlex Bennée .cmd = "Kill;", 2054*842b42dfSAlex Bennée .cmd_startswith = 1 2055*842b42dfSAlex Bennée }, 2056*842b42dfSAlex Bennée }; 2057*842b42dfSAlex Bennée 2058*842b42dfSAlex Bennée static void handle_v_commands(GArray *params, void *user_ctx) 2059*842b42dfSAlex Bennée { 2060*842b42dfSAlex Bennée if (!params->len) { 2061*842b42dfSAlex Bennée return; 2062*842b42dfSAlex Bennée } 2063*842b42dfSAlex Bennée 2064*842b42dfSAlex Bennée if (process_string_cmd(NULL, get_param(params, 0)->data, 2065*842b42dfSAlex Bennée gdb_v_commands_table, 2066*842b42dfSAlex Bennée ARRAY_SIZE(gdb_v_commands_table))) { 2067*842b42dfSAlex Bennée put_packet(""); 2068*842b42dfSAlex Bennée } 2069*842b42dfSAlex Bennée } 2070*842b42dfSAlex Bennée 2071*842b42dfSAlex Bennée static void handle_query_qemu_sstepbits(GArray *params, void *user_ctx) 2072*842b42dfSAlex Bennée { 2073*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "ENABLE=%x", SSTEP_ENABLE); 2074*842b42dfSAlex Bennée 2075*842b42dfSAlex Bennée if (gdbserver_state.supported_sstep_flags & SSTEP_NOIRQ) { 2076*842b42dfSAlex Bennée g_string_append_printf(gdbserver_state.str_buf, ",NOIRQ=%x", 2077*842b42dfSAlex Bennée SSTEP_NOIRQ); 2078*842b42dfSAlex Bennée } 2079*842b42dfSAlex Bennée 2080*842b42dfSAlex Bennée if (gdbserver_state.supported_sstep_flags & SSTEP_NOTIMER) { 2081*842b42dfSAlex Bennée g_string_append_printf(gdbserver_state.str_buf, ",NOTIMER=%x", 2082*842b42dfSAlex Bennée SSTEP_NOTIMER); 2083*842b42dfSAlex Bennée } 2084*842b42dfSAlex Bennée 2085*842b42dfSAlex Bennée put_strbuf(); 2086*842b42dfSAlex Bennée } 2087*842b42dfSAlex Bennée 2088*842b42dfSAlex Bennée static void handle_set_qemu_sstep(GArray *params, void *user_ctx) 2089*842b42dfSAlex Bennée { 2090*842b42dfSAlex Bennée int new_sstep_flags; 2091*842b42dfSAlex Bennée 2092*842b42dfSAlex Bennée if (!params->len) { 2093*842b42dfSAlex Bennée return; 2094*842b42dfSAlex Bennée } 2095*842b42dfSAlex Bennée 2096*842b42dfSAlex Bennée new_sstep_flags = get_param(params, 0)->val_ul; 2097*842b42dfSAlex Bennée 2098*842b42dfSAlex Bennée if (new_sstep_flags & ~gdbserver_state.supported_sstep_flags) { 2099*842b42dfSAlex Bennée put_packet("E22"); 2100*842b42dfSAlex Bennée return; 2101*842b42dfSAlex Bennée } 2102*842b42dfSAlex Bennée 2103*842b42dfSAlex Bennée gdbserver_state.sstep_flags = new_sstep_flags; 2104*842b42dfSAlex Bennée put_packet("OK"); 2105*842b42dfSAlex Bennée } 2106*842b42dfSAlex Bennée 2107*842b42dfSAlex Bennée static void handle_query_qemu_sstep(GArray *params, void *user_ctx) 2108*842b42dfSAlex Bennée { 2109*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "0x%x", 2110*842b42dfSAlex Bennée gdbserver_state.sstep_flags); 2111*842b42dfSAlex Bennée put_strbuf(); 2112*842b42dfSAlex Bennée } 2113*842b42dfSAlex Bennée 2114*842b42dfSAlex Bennée static void handle_query_curr_tid(GArray *params, void *user_ctx) 2115*842b42dfSAlex Bennée { 2116*842b42dfSAlex Bennée CPUState *cpu; 2117*842b42dfSAlex Bennée GDBProcess *process; 2118*842b42dfSAlex Bennée 2119*842b42dfSAlex Bennée /* 2120*842b42dfSAlex Bennée * "Current thread" remains vague in the spec, so always return 2121*842b42dfSAlex Bennée * the first thread of the current process (gdb returns the 2122*842b42dfSAlex Bennée * first thread). 2123*842b42dfSAlex Bennée */ 2124*842b42dfSAlex Bennée process = gdb_get_cpu_process(gdbserver_state.g_cpu); 2125*842b42dfSAlex Bennée cpu = get_first_cpu_in_process(process); 2126*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "QC"); 2127*842b42dfSAlex Bennée gdb_append_thread_id(cpu, gdbserver_state.str_buf); 2128*842b42dfSAlex Bennée put_strbuf(); 2129*842b42dfSAlex Bennée } 2130*842b42dfSAlex Bennée 2131*842b42dfSAlex Bennée static void handle_query_threads(GArray *params, void *user_ctx) 2132*842b42dfSAlex Bennée { 2133*842b42dfSAlex Bennée if (!gdbserver_state.query_cpu) { 2134*842b42dfSAlex Bennée put_packet("l"); 2135*842b42dfSAlex Bennée return; 2136*842b42dfSAlex Bennée } 2137*842b42dfSAlex Bennée 2138*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "m"); 2139*842b42dfSAlex Bennée gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf); 2140*842b42dfSAlex Bennée put_strbuf(); 2141*842b42dfSAlex Bennée gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu); 2142*842b42dfSAlex Bennée } 2143*842b42dfSAlex Bennée 2144*842b42dfSAlex Bennée static void handle_query_first_threads(GArray *params, void *user_ctx) 2145*842b42dfSAlex Bennée { 2146*842b42dfSAlex Bennée gdbserver_state.query_cpu = gdb_first_attached_cpu(); 2147*842b42dfSAlex Bennée handle_query_threads(params, user_ctx); 2148*842b42dfSAlex Bennée } 2149*842b42dfSAlex Bennée 2150*842b42dfSAlex Bennée static void handle_query_thread_extra(GArray *params, void *user_ctx) 2151*842b42dfSAlex Bennée { 2152*842b42dfSAlex Bennée g_autoptr(GString) rs = g_string_new(NULL); 2153*842b42dfSAlex Bennée CPUState *cpu; 2154*842b42dfSAlex Bennée 2155*842b42dfSAlex Bennée if (!params->len || 2156*842b42dfSAlex Bennée get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) { 2157*842b42dfSAlex Bennée put_packet("E22"); 2158*842b42dfSAlex Bennée return; 2159*842b42dfSAlex Bennée } 2160*842b42dfSAlex Bennée 2161*842b42dfSAlex Bennée cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid, 2162*842b42dfSAlex Bennée get_param(params, 0)->thread_id.tid); 2163*842b42dfSAlex Bennée if (!cpu) { 2164*842b42dfSAlex Bennée return; 2165*842b42dfSAlex Bennée } 2166*842b42dfSAlex Bennée 2167*842b42dfSAlex Bennée cpu_synchronize_state(cpu); 2168*842b42dfSAlex Bennée 2169*842b42dfSAlex Bennée if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) { 2170*842b42dfSAlex Bennée /* Print the CPU model and name in multiprocess mode */ 2171*842b42dfSAlex Bennée ObjectClass *oc = object_get_class(OBJECT(cpu)); 2172*842b42dfSAlex Bennée const char *cpu_model = object_class_get_name(oc); 2173*842b42dfSAlex Bennée const char *cpu_name = 2174*842b42dfSAlex Bennée object_get_canonical_path_component(OBJECT(cpu)); 2175*842b42dfSAlex Bennée g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name, 2176*842b42dfSAlex Bennée cpu->halted ? "halted " : "running"); 2177*842b42dfSAlex Bennée } else { 2178*842b42dfSAlex Bennée g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index, 2179*842b42dfSAlex Bennée cpu->halted ? "halted " : "running"); 2180*842b42dfSAlex Bennée } 2181*842b42dfSAlex Bennée trace_gdbstub_op_extra_info(rs->str); 2182*842b42dfSAlex Bennée memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len); 2183*842b42dfSAlex Bennée put_strbuf(); 2184*842b42dfSAlex Bennée } 2185*842b42dfSAlex Bennée 2186*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 2187*842b42dfSAlex Bennée static void handle_query_offsets(GArray *params, void *user_ctx) 2188*842b42dfSAlex Bennée { 2189*842b42dfSAlex Bennée TaskState *ts; 2190*842b42dfSAlex Bennée 2191*842b42dfSAlex Bennée ts = gdbserver_state.c_cpu->opaque; 2192*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, 2193*842b42dfSAlex Bennée "Text=" TARGET_ABI_FMT_lx 2194*842b42dfSAlex Bennée ";Data=" TARGET_ABI_FMT_lx 2195*842b42dfSAlex Bennée ";Bss=" TARGET_ABI_FMT_lx, 2196*842b42dfSAlex Bennée ts->info->code_offset, 2197*842b42dfSAlex Bennée ts->info->data_offset, 2198*842b42dfSAlex Bennée ts->info->data_offset); 2199*842b42dfSAlex Bennée put_strbuf(); 2200*842b42dfSAlex Bennée } 2201*842b42dfSAlex Bennée #else 2202*842b42dfSAlex Bennée static void handle_query_rcmd(GArray *params, void *user_ctx) 2203*842b42dfSAlex Bennée { 2204*842b42dfSAlex Bennée const guint8 zero = 0; 2205*842b42dfSAlex Bennée int len; 2206*842b42dfSAlex Bennée 2207*842b42dfSAlex Bennée if (!params->len) { 2208*842b42dfSAlex Bennée put_packet("E22"); 2209*842b42dfSAlex Bennée return; 2210*842b42dfSAlex Bennée } 2211*842b42dfSAlex Bennée 2212*842b42dfSAlex Bennée len = strlen(get_param(params, 0)->data); 2213*842b42dfSAlex Bennée if (len % 2) { 2214*842b42dfSAlex Bennée put_packet("E01"); 2215*842b42dfSAlex Bennée return; 2216*842b42dfSAlex Bennée } 2217*842b42dfSAlex Bennée 2218*842b42dfSAlex Bennée g_assert(gdbserver_state.mem_buf->len == 0); 2219*842b42dfSAlex Bennée len = len / 2; 2220*842b42dfSAlex Bennée hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len); 2221*842b42dfSAlex Bennée g_byte_array_append(gdbserver_state.mem_buf, &zero, 1); 2222*842b42dfSAlex Bennée qemu_chr_be_write(gdbserver_state.mon_chr, gdbserver_state.mem_buf->data, 2223*842b42dfSAlex Bennée gdbserver_state.mem_buf->len); 2224*842b42dfSAlex Bennée put_packet("OK"); 2225*842b42dfSAlex Bennée } 2226*842b42dfSAlex Bennée #endif 2227*842b42dfSAlex Bennée 2228*842b42dfSAlex Bennée static void handle_query_supported(GArray *params, void *user_ctx) 2229*842b42dfSAlex Bennée { 2230*842b42dfSAlex Bennée CPUClass *cc; 2231*842b42dfSAlex Bennée 2232*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH); 2233*842b42dfSAlex Bennée cc = CPU_GET_CLASS(first_cpu); 2234*842b42dfSAlex Bennée if (cc->gdb_core_xml_file) { 2235*842b42dfSAlex Bennée g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+"); 2236*842b42dfSAlex Bennée } 2237*842b42dfSAlex Bennée 2238*842b42dfSAlex Bennée if (stub_can_reverse()) { 2239*842b42dfSAlex Bennée g_string_append(gdbserver_state.str_buf, 2240*842b42dfSAlex Bennée ";ReverseStep+;ReverseContinue+"); 2241*842b42dfSAlex Bennée } 2242*842b42dfSAlex Bennée 2243*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 2244*842b42dfSAlex Bennée if (gdbserver_state.c_cpu->opaque) { 2245*842b42dfSAlex Bennée g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+"); 2246*842b42dfSAlex Bennée } 2247*842b42dfSAlex Bennée #endif 2248*842b42dfSAlex Bennée 2249*842b42dfSAlex Bennée if (params->len && 2250*842b42dfSAlex Bennée strstr(get_param(params, 0)->data, "multiprocess+")) { 2251*842b42dfSAlex Bennée gdbserver_state.multiprocess = true; 2252*842b42dfSAlex Bennée } 2253*842b42dfSAlex Bennée 2254*842b42dfSAlex Bennée g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+"); 2255*842b42dfSAlex Bennée put_strbuf(); 2256*842b42dfSAlex Bennée } 2257*842b42dfSAlex Bennée 2258*842b42dfSAlex Bennée static void handle_query_xfer_features(GArray *params, void *user_ctx) 2259*842b42dfSAlex Bennée { 2260*842b42dfSAlex Bennée GDBProcess *process; 2261*842b42dfSAlex Bennée CPUClass *cc; 2262*842b42dfSAlex Bennée unsigned long len, total_len, addr; 2263*842b42dfSAlex Bennée const char *xml; 2264*842b42dfSAlex Bennée const char *p; 2265*842b42dfSAlex Bennée 2266*842b42dfSAlex Bennée if (params->len < 3) { 2267*842b42dfSAlex Bennée put_packet("E22"); 2268*842b42dfSAlex Bennée return; 2269*842b42dfSAlex Bennée } 2270*842b42dfSAlex Bennée 2271*842b42dfSAlex Bennée process = gdb_get_cpu_process(gdbserver_state.g_cpu); 2272*842b42dfSAlex Bennée cc = CPU_GET_CLASS(gdbserver_state.g_cpu); 2273*842b42dfSAlex Bennée if (!cc->gdb_core_xml_file) { 2274*842b42dfSAlex Bennée put_packet(""); 2275*842b42dfSAlex Bennée return; 2276*842b42dfSAlex Bennée } 2277*842b42dfSAlex Bennée 2278*842b42dfSAlex Bennée gdb_has_xml = true; 2279*842b42dfSAlex Bennée p = get_param(params, 0)->data; 2280*842b42dfSAlex Bennée xml = get_feature_xml(p, &p, process); 2281*842b42dfSAlex Bennée if (!xml) { 2282*842b42dfSAlex Bennée put_packet("E00"); 2283*842b42dfSAlex Bennée return; 2284*842b42dfSAlex Bennée } 2285*842b42dfSAlex Bennée 2286*842b42dfSAlex Bennée addr = get_param(params, 1)->val_ul; 2287*842b42dfSAlex Bennée len = get_param(params, 2)->val_ul; 2288*842b42dfSAlex Bennée total_len = strlen(xml); 2289*842b42dfSAlex Bennée if (addr > total_len) { 2290*842b42dfSAlex Bennée put_packet("E00"); 2291*842b42dfSAlex Bennée return; 2292*842b42dfSAlex Bennée } 2293*842b42dfSAlex Bennée 2294*842b42dfSAlex Bennée if (len > (MAX_PACKET_LENGTH - 5) / 2) { 2295*842b42dfSAlex Bennée len = (MAX_PACKET_LENGTH - 5) / 2; 2296*842b42dfSAlex Bennée } 2297*842b42dfSAlex Bennée 2298*842b42dfSAlex Bennée if (len < total_len - addr) { 2299*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "m"); 2300*842b42dfSAlex Bennée memtox(gdbserver_state.str_buf, xml + addr, len); 2301*842b42dfSAlex Bennée } else { 2302*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "l"); 2303*842b42dfSAlex Bennée memtox(gdbserver_state.str_buf, xml + addr, total_len - addr); 2304*842b42dfSAlex Bennée } 2305*842b42dfSAlex Bennée 2306*842b42dfSAlex Bennée put_packet_binary(gdbserver_state.str_buf->str, 2307*842b42dfSAlex Bennée gdbserver_state.str_buf->len, true); 2308*842b42dfSAlex Bennée } 2309*842b42dfSAlex Bennée 2310*842b42dfSAlex Bennée #if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER) 2311*842b42dfSAlex Bennée static void handle_query_xfer_auxv(GArray *params, void *user_ctx) 2312*842b42dfSAlex Bennée { 2313*842b42dfSAlex Bennée TaskState *ts; 2314*842b42dfSAlex Bennée unsigned long offset, len, saved_auxv, auxv_len; 2315*842b42dfSAlex Bennée 2316*842b42dfSAlex Bennée if (params->len < 2) { 2317*842b42dfSAlex Bennée put_packet("E22"); 2318*842b42dfSAlex Bennée return; 2319*842b42dfSAlex Bennée } 2320*842b42dfSAlex Bennée 2321*842b42dfSAlex Bennée offset = get_param(params, 0)->val_ul; 2322*842b42dfSAlex Bennée len = get_param(params, 1)->val_ul; 2323*842b42dfSAlex Bennée ts = gdbserver_state.c_cpu->opaque; 2324*842b42dfSAlex Bennée saved_auxv = ts->info->saved_auxv; 2325*842b42dfSAlex Bennée auxv_len = ts->info->auxv_len; 2326*842b42dfSAlex Bennée 2327*842b42dfSAlex Bennée if (offset >= auxv_len) { 2328*842b42dfSAlex Bennée put_packet("E00"); 2329*842b42dfSAlex Bennée return; 2330*842b42dfSAlex Bennée } 2331*842b42dfSAlex Bennée 2332*842b42dfSAlex Bennée if (len > (MAX_PACKET_LENGTH - 5) / 2) { 2333*842b42dfSAlex Bennée len = (MAX_PACKET_LENGTH - 5) / 2; 2334*842b42dfSAlex Bennée } 2335*842b42dfSAlex Bennée 2336*842b42dfSAlex Bennée if (len < auxv_len - offset) { 2337*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "m"); 2338*842b42dfSAlex Bennée } else { 2339*842b42dfSAlex Bennée g_string_assign(gdbserver_state.str_buf, "l"); 2340*842b42dfSAlex Bennée len = auxv_len - offset; 2341*842b42dfSAlex Bennée } 2342*842b42dfSAlex Bennée 2343*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.mem_buf, len); 2344*842b42dfSAlex Bennée if (target_memory_rw_debug(gdbserver_state.g_cpu, saved_auxv + offset, 2345*842b42dfSAlex Bennée gdbserver_state.mem_buf->data, len, false)) { 2346*842b42dfSAlex Bennée put_packet("E14"); 2347*842b42dfSAlex Bennée return; 2348*842b42dfSAlex Bennée } 2349*842b42dfSAlex Bennée 2350*842b42dfSAlex Bennée memtox(gdbserver_state.str_buf, 2351*842b42dfSAlex Bennée (const char *)gdbserver_state.mem_buf->data, len); 2352*842b42dfSAlex Bennée put_packet_binary(gdbserver_state.str_buf->str, 2353*842b42dfSAlex Bennée gdbserver_state.str_buf->len, true); 2354*842b42dfSAlex Bennée } 2355*842b42dfSAlex Bennée #endif 2356*842b42dfSAlex Bennée 2357*842b42dfSAlex Bennée static void handle_query_attached(GArray *params, void *user_ctx) 2358*842b42dfSAlex Bennée { 2359*842b42dfSAlex Bennée put_packet(GDB_ATTACHED); 2360*842b42dfSAlex Bennée } 2361*842b42dfSAlex Bennée 2362*842b42dfSAlex Bennée static void handle_query_qemu_supported(GArray *params, void *user_ctx) 2363*842b42dfSAlex Bennée { 2364*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep"); 2365*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 2366*842b42dfSAlex Bennée g_string_append(gdbserver_state.str_buf, ";PhyMemMode"); 2367*842b42dfSAlex Bennée #endif 2368*842b42dfSAlex Bennée put_strbuf(); 2369*842b42dfSAlex Bennée } 2370*842b42dfSAlex Bennée 2371*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 2372*842b42dfSAlex Bennée static void handle_query_qemu_phy_mem_mode(GArray *params, 2373*842b42dfSAlex Bennée void *user_ctx) 2374*842b42dfSAlex Bennée { 2375*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "%d", phy_memory_mode); 2376*842b42dfSAlex Bennée put_strbuf(); 2377*842b42dfSAlex Bennée } 2378*842b42dfSAlex Bennée 2379*842b42dfSAlex Bennée static void handle_set_qemu_phy_mem_mode(GArray *params, void *user_ctx) 2380*842b42dfSAlex Bennée { 2381*842b42dfSAlex Bennée if (!params->len) { 2382*842b42dfSAlex Bennée put_packet("E22"); 2383*842b42dfSAlex Bennée return; 2384*842b42dfSAlex Bennée } 2385*842b42dfSAlex Bennée 2386*842b42dfSAlex Bennée if (!get_param(params, 0)->val_ul) { 2387*842b42dfSAlex Bennée phy_memory_mode = 0; 2388*842b42dfSAlex Bennée } else { 2389*842b42dfSAlex Bennée phy_memory_mode = 1; 2390*842b42dfSAlex Bennée } 2391*842b42dfSAlex Bennée put_packet("OK"); 2392*842b42dfSAlex Bennée } 2393*842b42dfSAlex Bennée #endif 2394*842b42dfSAlex Bennée 2395*842b42dfSAlex Bennée static const GdbCmdParseEntry gdb_gen_query_set_common_table[] = { 2396*842b42dfSAlex Bennée /* Order is important if has same prefix */ 2397*842b42dfSAlex Bennée { 2398*842b42dfSAlex Bennée .handler = handle_query_qemu_sstepbits, 2399*842b42dfSAlex Bennée .cmd = "qemu.sstepbits", 2400*842b42dfSAlex Bennée }, 2401*842b42dfSAlex Bennée { 2402*842b42dfSAlex Bennée .handler = handle_query_qemu_sstep, 2403*842b42dfSAlex Bennée .cmd = "qemu.sstep", 2404*842b42dfSAlex Bennée }, 2405*842b42dfSAlex Bennée { 2406*842b42dfSAlex Bennée .handler = handle_set_qemu_sstep, 2407*842b42dfSAlex Bennée .cmd = "qemu.sstep=", 2408*842b42dfSAlex Bennée .cmd_startswith = 1, 2409*842b42dfSAlex Bennée .schema = "l0" 2410*842b42dfSAlex Bennée }, 2411*842b42dfSAlex Bennée }; 2412*842b42dfSAlex Bennée 2413*842b42dfSAlex Bennée static const GdbCmdParseEntry gdb_gen_query_table[] = { 2414*842b42dfSAlex Bennée { 2415*842b42dfSAlex Bennée .handler = handle_query_curr_tid, 2416*842b42dfSAlex Bennée .cmd = "C", 2417*842b42dfSAlex Bennée }, 2418*842b42dfSAlex Bennée { 2419*842b42dfSAlex Bennée .handler = handle_query_threads, 2420*842b42dfSAlex Bennée .cmd = "sThreadInfo", 2421*842b42dfSAlex Bennée }, 2422*842b42dfSAlex Bennée { 2423*842b42dfSAlex Bennée .handler = handle_query_first_threads, 2424*842b42dfSAlex Bennée .cmd = "fThreadInfo", 2425*842b42dfSAlex Bennée }, 2426*842b42dfSAlex Bennée { 2427*842b42dfSAlex Bennée .handler = handle_query_thread_extra, 2428*842b42dfSAlex Bennée .cmd = "ThreadExtraInfo,", 2429*842b42dfSAlex Bennée .cmd_startswith = 1, 2430*842b42dfSAlex Bennée .schema = "t0" 2431*842b42dfSAlex Bennée }, 2432*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 2433*842b42dfSAlex Bennée { 2434*842b42dfSAlex Bennée .handler = handle_query_offsets, 2435*842b42dfSAlex Bennée .cmd = "Offsets", 2436*842b42dfSAlex Bennée }, 2437*842b42dfSAlex Bennée #else 2438*842b42dfSAlex Bennée { 2439*842b42dfSAlex Bennée .handler = handle_query_rcmd, 2440*842b42dfSAlex Bennée .cmd = "Rcmd,", 2441*842b42dfSAlex Bennée .cmd_startswith = 1, 2442*842b42dfSAlex Bennée .schema = "s0" 2443*842b42dfSAlex Bennée }, 2444*842b42dfSAlex Bennée #endif 2445*842b42dfSAlex Bennée { 2446*842b42dfSAlex Bennée .handler = handle_query_supported, 2447*842b42dfSAlex Bennée .cmd = "Supported:", 2448*842b42dfSAlex Bennée .cmd_startswith = 1, 2449*842b42dfSAlex Bennée .schema = "s0" 2450*842b42dfSAlex Bennée }, 2451*842b42dfSAlex Bennée { 2452*842b42dfSAlex Bennée .handler = handle_query_supported, 2453*842b42dfSAlex Bennée .cmd = "Supported", 2454*842b42dfSAlex Bennée .schema = "s0" 2455*842b42dfSAlex Bennée }, 2456*842b42dfSAlex Bennée { 2457*842b42dfSAlex Bennée .handler = handle_query_xfer_features, 2458*842b42dfSAlex Bennée .cmd = "Xfer:features:read:", 2459*842b42dfSAlex Bennée .cmd_startswith = 1, 2460*842b42dfSAlex Bennée .schema = "s:l,l0" 2461*842b42dfSAlex Bennée }, 2462*842b42dfSAlex Bennée #if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER) 2463*842b42dfSAlex Bennée { 2464*842b42dfSAlex Bennée .handler = handle_query_xfer_auxv, 2465*842b42dfSAlex Bennée .cmd = "Xfer:auxv:read::", 2466*842b42dfSAlex Bennée .cmd_startswith = 1, 2467*842b42dfSAlex Bennée .schema = "l,l0" 2468*842b42dfSAlex Bennée }, 2469*842b42dfSAlex Bennée #endif 2470*842b42dfSAlex Bennée { 2471*842b42dfSAlex Bennée .handler = handle_query_attached, 2472*842b42dfSAlex Bennée .cmd = "Attached:", 2473*842b42dfSAlex Bennée .cmd_startswith = 1 2474*842b42dfSAlex Bennée }, 2475*842b42dfSAlex Bennée { 2476*842b42dfSAlex Bennée .handler = handle_query_attached, 2477*842b42dfSAlex Bennée .cmd = "Attached", 2478*842b42dfSAlex Bennée }, 2479*842b42dfSAlex Bennée { 2480*842b42dfSAlex Bennée .handler = handle_query_qemu_supported, 2481*842b42dfSAlex Bennée .cmd = "qemu.Supported", 2482*842b42dfSAlex Bennée }, 2483*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 2484*842b42dfSAlex Bennée { 2485*842b42dfSAlex Bennée .handler = handle_query_qemu_phy_mem_mode, 2486*842b42dfSAlex Bennée .cmd = "qemu.PhyMemMode", 2487*842b42dfSAlex Bennée }, 2488*842b42dfSAlex Bennée #endif 2489*842b42dfSAlex Bennée }; 2490*842b42dfSAlex Bennée 2491*842b42dfSAlex Bennée static const GdbCmdParseEntry gdb_gen_set_table[] = { 2492*842b42dfSAlex Bennée /* Order is important if has same prefix */ 2493*842b42dfSAlex Bennée { 2494*842b42dfSAlex Bennée .handler = handle_set_qemu_sstep, 2495*842b42dfSAlex Bennée .cmd = "qemu.sstep:", 2496*842b42dfSAlex Bennée .cmd_startswith = 1, 2497*842b42dfSAlex Bennée .schema = "l0" 2498*842b42dfSAlex Bennée }, 2499*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 2500*842b42dfSAlex Bennée { 2501*842b42dfSAlex Bennée .handler = handle_set_qemu_phy_mem_mode, 2502*842b42dfSAlex Bennée .cmd = "qemu.PhyMemMode:", 2503*842b42dfSAlex Bennée .cmd_startswith = 1, 2504*842b42dfSAlex Bennée .schema = "l0" 2505*842b42dfSAlex Bennée }, 2506*842b42dfSAlex Bennée #endif 2507*842b42dfSAlex Bennée }; 2508*842b42dfSAlex Bennée 2509*842b42dfSAlex Bennée static void handle_gen_query(GArray *params, void *user_ctx) 2510*842b42dfSAlex Bennée { 2511*842b42dfSAlex Bennée if (!params->len) { 2512*842b42dfSAlex Bennée return; 2513*842b42dfSAlex Bennée } 2514*842b42dfSAlex Bennée 2515*842b42dfSAlex Bennée if (!process_string_cmd(NULL, get_param(params, 0)->data, 2516*842b42dfSAlex Bennée gdb_gen_query_set_common_table, 2517*842b42dfSAlex Bennée ARRAY_SIZE(gdb_gen_query_set_common_table))) { 2518*842b42dfSAlex Bennée return; 2519*842b42dfSAlex Bennée } 2520*842b42dfSAlex Bennée 2521*842b42dfSAlex Bennée if (process_string_cmd(NULL, get_param(params, 0)->data, 2522*842b42dfSAlex Bennée gdb_gen_query_table, 2523*842b42dfSAlex Bennée ARRAY_SIZE(gdb_gen_query_table))) { 2524*842b42dfSAlex Bennée put_packet(""); 2525*842b42dfSAlex Bennée } 2526*842b42dfSAlex Bennée } 2527*842b42dfSAlex Bennée 2528*842b42dfSAlex Bennée static void handle_gen_set(GArray *params, void *user_ctx) 2529*842b42dfSAlex Bennée { 2530*842b42dfSAlex Bennée if (!params->len) { 2531*842b42dfSAlex Bennée return; 2532*842b42dfSAlex Bennée } 2533*842b42dfSAlex Bennée 2534*842b42dfSAlex Bennée if (!process_string_cmd(NULL, get_param(params, 0)->data, 2535*842b42dfSAlex Bennée gdb_gen_query_set_common_table, 2536*842b42dfSAlex Bennée ARRAY_SIZE(gdb_gen_query_set_common_table))) { 2537*842b42dfSAlex Bennée return; 2538*842b42dfSAlex Bennée } 2539*842b42dfSAlex Bennée 2540*842b42dfSAlex Bennée if (process_string_cmd(NULL, get_param(params, 0)->data, 2541*842b42dfSAlex Bennée gdb_gen_set_table, 2542*842b42dfSAlex Bennée ARRAY_SIZE(gdb_gen_set_table))) { 2543*842b42dfSAlex Bennée put_packet(""); 2544*842b42dfSAlex Bennée } 2545*842b42dfSAlex Bennée } 2546*842b42dfSAlex Bennée 2547*842b42dfSAlex Bennée static void handle_target_halt(GArray *params, void *user_ctx) 2548*842b42dfSAlex Bennée { 2549*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP); 2550*842b42dfSAlex Bennée gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf); 2551*842b42dfSAlex Bennée g_string_append_c(gdbserver_state.str_buf, ';'); 2552*842b42dfSAlex Bennée put_strbuf(); 2553*842b42dfSAlex Bennée /* 2554*842b42dfSAlex Bennée * Remove all the breakpoints when this query is issued, 2555*842b42dfSAlex Bennée * because gdb is doing an initial connect and the state 2556*842b42dfSAlex Bennée * should be cleaned up. 2557*842b42dfSAlex Bennée */ 2558*842b42dfSAlex Bennée gdb_breakpoint_remove_all(); 2559*842b42dfSAlex Bennée } 2560*842b42dfSAlex Bennée 2561*842b42dfSAlex Bennée static int gdb_handle_packet(const char *line_buf) 2562*842b42dfSAlex Bennée { 2563*842b42dfSAlex Bennée const GdbCmdParseEntry *cmd_parser = NULL; 2564*842b42dfSAlex Bennée 2565*842b42dfSAlex Bennée trace_gdbstub_io_command(line_buf); 2566*842b42dfSAlex Bennée 2567*842b42dfSAlex Bennée switch (line_buf[0]) { 2568*842b42dfSAlex Bennée case '!': 2569*842b42dfSAlex Bennée put_packet("OK"); 2570*842b42dfSAlex Bennée break; 2571*842b42dfSAlex Bennée case '?': 2572*842b42dfSAlex Bennée { 2573*842b42dfSAlex Bennée static const GdbCmdParseEntry target_halted_cmd_desc = { 2574*842b42dfSAlex Bennée .handler = handle_target_halt, 2575*842b42dfSAlex Bennée .cmd = "?", 2576*842b42dfSAlex Bennée .cmd_startswith = 1 2577*842b42dfSAlex Bennée }; 2578*842b42dfSAlex Bennée cmd_parser = &target_halted_cmd_desc; 2579*842b42dfSAlex Bennée } 2580*842b42dfSAlex Bennée break; 2581*842b42dfSAlex Bennée case 'c': 2582*842b42dfSAlex Bennée { 2583*842b42dfSAlex Bennée static const GdbCmdParseEntry continue_cmd_desc = { 2584*842b42dfSAlex Bennée .handler = handle_continue, 2585*842b42dfSAlex Bennée .cmd = "c", 2586*842b42dfSAlex Bennée .cmd_startswith = 1, 2587*842b42dfSAlex Bennée .schema = "L0" 2588*842b42dfSAlex Bennée }; 2589*842b42dfSAlex Bennée cmd_parser = &continue_cmd_desc; 2590*842b42dfSAlex Bennée } 2591*842b42dfSAlex Bennée break; 2592*842b42dfSAlex Bennée case 'C': 2593*842b42dfSAlex Bennée { 2594*842b42dfSAlex Bennée static const GdbCmdParseEntry cont_with_sig_cmd_desc = { 2595*842b42dfSAlex Bennée .handler = handle_cont_with_sig, 2596*842b42dfSAlex Bennée .cmd = "C", 2597*842b42dfSAlex Bennée .cmd_startswith = 1, 2598*842b42dfSAlex Bennée .schema = "l0" 2599*842b42dfSAlex Bennée }; 2600*842b42dfSAlex Bennée cmd_parser = &cont_with_sig_cmd_desc; 2601*842b42dfSAlex Bennée } 2602*842b42dfSAlex Bennée break; 2603*842b42dfSAlex Bennée case 'v': 2604*842b42dfSAlex Bennée { 2605*842b42dfSAlex Bennée static const GdbCmdParseEntry v_cmd_desc = { 2606*842b42dfSAlex Bennée .handler = handle_v_commands, 2607*842b42dfSAlex Bennée .cmd = "v", 2608*842b42dfSAlex Bennée .cmd_startswith = 1, 2609*842b42dfSAlex Bennée .schema = "s0" 2610*842b42dfSAlex Bennée }; 2611*842b42dfSAlex Bennée cmd_parser = &v_cmd_desc; 2612*842b42dfSAlex Bennée } 2613*842b42dfSAlex Bennée break; 2614*842b42dfSAlex Bennée case 'k': 2615*842b42dfSAlex Bennée /* Kill the target */ 2616*842b42dfSAlex Bennée error_report("QEMU: Terminated via GDBstub"); 2617*842b42dfSAlex Bennée gdb_exit(0); 2618*842b42dfSAlex Bennée exit(0); 2619*842b42dfSAlex Bennée case 'D': 2620*842b42dfSAlex Bennée { 2621*842b42dfSAlex Bennée static const GdbCmdParseEntry detach_cmd_desc = { 2622*842b42dfSAlex Bennée .handler = handle_detach, 2623*842b42dfSAlex Bennée .cmd = "D", 2624*842b42dfSAlex Bennée .cmd_startswith = 1, 2625*842b42dfSAlex Bennée .schema = "?.l0" 2626*842b42dfSAlex Bennée }; 2627*842b42dfSAlex Bennée cmd_parser = &detach_cmd_desc; 2628*842b42dfSAlex Bennée } 2629*842b42dfSAlex Bennée break; 2630*842b42dfSAlex Bennée case 's': 2631*842b42dfSAlex Bennée { 2632*842b42dfSAlex Bennée static const GdbCmdParseEntry step_cmd_desc = { 2633*842b42dfSAlex Bennée .handler = handle_step, 2634*842b42dfSAlex Bennée .cmd = "s", 2635*842b42dfSAlex Bennée .cmd_startswith = 1, 2636*842b42dfSAlex Bennée .schema = "L0" 2637*842b42dfSAlex Bennée }; 2638*842b42dfSAlex Bennée cmd_parser = &step_cmd_desc; 2639*842b42dfSAlex Bennée } 2640*842b42dfSAlex Bennée break; 2641*842b42dfSAlex Bennée case 'b': 2642*842b42dfSAlex Bennée { 2643*842b42dfSAlex Bennée static const GdbCmdParseEntry backward_cmd_desc = { 2644*842b42dfSAlex Bennée .handler = handle_backward, 2645*842b42dfSAlex Bennée .cmd = "b", 2646*842b42dfSAlex Bennée .cmd_startswith = 1, 2647*842b42dfSAlex Bennée .schema = "o0" 2648*842b42dfSAlex Bennée }; 2649*842b42dfSAlex Bennée cmd_parser = &backward_cmd_desc; 2650*842b42dfSAlex Bennée } 2651*842b42dfSAlex Bennée break; 2652*842b42dfSAlex Bennée case 'F': 2653*842b42dfSAlex Bennée { 2654*842b42dfSAlex Bennée static const GdbCmdParseEntry file_io_cmd_desc = { 2655*842b42dfSAlex Bennée .handler = handle_file_io, 2656*842b42dfSAlex Bennée .cmd = "F", 2657*842b42dfSAlex Bennée .cmd_startswith = 1, 2658*842b42dfSAlex Bennée .schema = "L,L,o0" 2659*842b42dfSAlex Bennée }; 2660*842b42dfSAlex Bennée cmd_parser = &file_io_cmd_desc; 2661*842b42dfSAlex Bennée } 2662*842b42dfSAlex Bennée break; 2663*842b42dfSAlex Bennée case 'g': 2664*842b42dfSAlex Bennée { 2665*842b42dfSAlex Bennée static const GdbCmdParseEntry read_all_regs_cmd_desc = { 2666*842b42dfSAlex Bennée .handler = handle_read_all_regs, 2667*842b42dfSAlex Bennée .cmd = "g", 2668*842b42dfSAlex Bennée .cmd_startswith = 1 2669*842b42dfSAlex Bennée }; 2670*842b42dfSAlex Bennée cmd_parser = &read_all_regs_cmd_desc; 2671*842b42dfSAlex Bennée } 2672*842b42dfSAlex Bennée break; 2673*842b42dfSAlex Bennée case 'G': 2674*842b42dfSAlex Bennée { 2675*842b42dfSAlex Bennée static const GdbCmdParseEntry write_all_regs_cmd_desc = { 2676*842b42dfSAlex Bennée .handler = handle_write_all_regs, 2677*842b42dfSAlex Bennée .cmd = "G", 2678*842b42dfSAlex Bennée .cmd_startswith = 1, 2679*842b42dfSAlex Bennée .schema = "s0" 2680*842b42dfSAlex Bennée }; 2681*842b42dfSAlex Bennée cmd_parser = &write_all_regs_cmd_desc; 2682*842b42dfSAlex Bennée } 2683*842b42dfSAlex Bennée break; 2684*842b42dfSAlex Bennée case 'm': 2685*842b42dfSAlex Bennée { 2686*842b42dfSAlex Bennée static const GdbCmdParseEntry read_mem_cmd_desc = { 2687*842b42dfSAlex Bennée .handler = handle_read_mem, 2688*842b42dfSAlex Bennée .cmd = "m", 2689*842b42dfSAlex Bennée .cmd_startswith = 1, 2690*842b42dfSAlex Bennée .schema = "L,L0" 2691*842b42dfSAlex Bennée }; 2692*842b42dfSAlex Bennée cmd_parser = &read_mem_cmd_desc; 2693*842b42dfSAlex Bennée } 2694*842b42dfSAlex Bennée break; 2695*842b42dfSAlex Bennée case 'M': 2696*842b42dfSAlex Bennée { 2697*842b42dfSAlex Bennée static const GdbCmdParseEntry write_mem_cmd_desc = { 2698*842b42dfSAlex Bennée .handler = handle_write_mem, 2699*842b42dfSAlex Bennée .cmd = "M", 2700*842b42dfSAlex Bennée .cmd_startswith = 1, 2701*842b42dfSAlex Bennée .schema = "L,L:s0" 2702*842b42dfSAlex Bennée }; 2703*842b42dfSAlex Bennée cmd_parser = &write_mem_cmd_desc; 2704*842b42dfSAlex Bennée } 2705*842b42dfSAlex Bennée break; 2706*842b42dfSAlex Bennée case 'p': 2707*842b42dfSAlex Bennée { 2708*842b42dfSAlex Bennée static const GdbCmdParseEntry get_reg_cmd_desc = { 2709*842b42dfSAlex Bennée .handler = handle_get_reg, 2710*842b42dfSAlex Bennée .cmd = "p", 2711*842b42dfSAlex Bennée .cmd_startswith = 1, 2712*842b42dfSAlex Bennée .schema = "L0" 2713*842b42dfSAlex Bennée }; 2714*842b42dfSAlex Bennée cmd_parser = &get_reg_cmd_desc; 2715*842b42dfSAlex Bennée } 2716*842b42dfSAlex Bennée break; 2717*842b42dfSAlex Bennée case 'P': 2718*842b42dfSAlex Bennée { 2719*842b42dfSAlex Bennée static const GdbCmdParseEntry set_reg_cmd_desc = { 2720*842b42dfSAlex Bennée .handler = handle_set_reg, 2721*842b42dfSAlex Bennée .cmd = "P", 2722*842b42dfSAlex Bennée .cmd_startswith = 1, 2723*842b42dfSAlex Bennée .schema = "L?s0" 2724*842b42dfSAlex Bennée }; 2725*842b42dfSAlex Bennée cmd_parser = &set_reg_cmd_desc; 2726*842b42dfSAlex Bennée } 2727*842b42dfSAlex Bennée break; 2728*842b42dfSAlex Bennée case 'Z': 2729*842b42dfSAlex Bennée { 2730*842b42dfSAlex Bennée static const GdbCmdParseEntry insert_bp_cmd_desc = { 2731*842b42dfSAlex Bennée .handler = handle_insert_bp, 2732*842b42dfSAlex Bennée .cmd = "Z", 2733*842b42dfSAlex Bennée .cmd_startswith = 1, 2734*842b42dfSAlex Bennée .schema = "l?L?L0" 2735*842b42dfSAlex Bennée }; 2736*842b42dfSAlex Bennée cmd_parser = &insert_bp_cmd_desc; 2737*842b42dfSAlex Bennée } 2738*842b42dfSAlex Bennée break; 2739*842b42dfSAlex Bennée case 'z': 2740*842b42dfSAlex Bennée { 2741*842b42dfSAlex Bennée static const GdbCmdParseEntry remove_bp_cmd_desc = { 2742*842b42dfSAlex Bennée .handler = handle_remove_bp, 2743*842b42dfSAlex Bennée .cmd = "z", 2744*842b42dfSAlex Bennée .cmd_startswith = 1, 2745*842b42dfSAlex Bennée .schema = "l?L?L0" 2746*842b42dfSAlex Bennée }; 2747*842b42dfSAlex Bennée cmd_parser = &remove_bp_cmd_desc; 2748*842b42dfSAlex Bennée } 2749*842b42dfSAlex Bennée break; 2750*842b42dfSAlex Bennée case 'H': 2751*842b42dfSAlex Bennée { 2752*842b42dfSAlex Bennée static const GdbCmdParseEntry set_thread_cmd_desc = { 2753*842b42dfSAlex Bennée .handler = handle_set_thread, 2754*842b42dfSAlex Bennée .cmd = "H", 2755*842b42dfSAlex Bennée .cmd_startswith = 1, 2756*842b42dfSAlex Bennée .schema = "o.t0" 2757*842b42dfSAlex Bennée }; 2758*842b42dfSAlex Bennée cmd_parser = &set_thread_cmd_desc; 2759*842b42dfSAlex Bennée } 2760*842b42dfSAlex Bennée break; 2761*842b42dfSAlex Bennée case 'T': 2762*842b42dfSAlex Bennée { 2763*842b42dfSAlex Bennée static const GdbCmdParseEntry thread_alive_cmd_desc = { 2764*842b42dfSAlex Bennée .handler = handle_thread_alive, 2765*842b42dfSAlex Bennée .cmd = "T", 2766*842b42dfSAlex Bennée .cmd_startswith = 1, 2767*842b42dfSAlex Bennée .schema = "t0" 2768*842b42dfSAlex Bennée }; 2769*842b42dfSAlex Bennée cmd_parser = &thread_alive_cmd_desc; 2770*842b42dfSAlex Bennée } 2771*842b42dfSAlex Bennée break; 2772*842b42dfSAlex Bennée case 'q': 2773*842b42dfSAlex Bennée { 2774*842b42dfSAlex Bennée static const GdbCmdParseEntry gen_query_cmd_desc = { 2775*842b42dfSAlex Bennée .handler = handle_gen_query, 2776*842b42dfSAlex Bennée .cmd = "q", 2777*842b42dfSAlex Bennée .cmd_startswith = 1, 2778*842b42dfSAlex Bennée .schema = "s0" 2779*842b42dfSAlex Bennée }; 2780*842b42dfSAlex Bennée cmd_parser = &gen_query_cmd_desc; 2781*842b42dfSAlex Bennée } 2782*842b42dfSAlex Bennée break; 2783*842b42dfSAlex Bennée case 'Q': 2784*842b42dfSAlex Bennée { 2785*842b42dfSAlex Bennée static const GdbCmdParseEntry gen_set_cmd_desc = { 2786*842b42dfSAlex Bennée .handler = handle_gen_set, 2787*842b42dfSAlex Bennée .cmd = "Q", 2788*842b42dfSAlex Bennée .cmd_startswith = 1, 2789*842b42dfSAlex Bennée .schema = "s0" 2790*842b42dfSAlex Bennée }; 2791*842b42dfSAlex Bennée cmd_parser = &gen_set_cmd_desc; 2792*842b42dfSAlex Bennée } 2793*842b42dfSAlex Bennée break; 2794*842b42dfSAlex Bennée default: 2795*842b42dfSAlex Bennée /* put empty packet */ 2796*842b42dfSAlex Bennée put_packet(""); 2797*842b42dfSAlex Bennée break; 2798*842b42dfSAlex Bennée } 2799*842b42dfSAlex Bennée 2800*842b42dfSAlex Bennée if (cmd_parser) { 2801*842b42dfSAlex Bennée run_cmd_parser(line_buf, cmd_parser); 2802*842b42dfSAlex Bennée } 2803*842b42dfSAlex Bennée 2804*842b42dfSAlex Bennée return RS_IDLE; 2805*842b42dfSAlex Bennée } 2806*842b42dfSAlex Bennée 2807*842b42dfSAlex Bennée void gdb_set_stop_cpu(CPUState *cpu) 2808*842b42dfSAlex Bennée { 2809*842b42dfSAlex Bennée GDBProcess *p = gdb_get_cpu_process(cpu); 2810*842b42dfSAlex Bennée 2811*842b42dfSAlex Bennée if (!p->attached) { 2812*842b42dfSAlex Bennée /* 2813*842b42dfSAlex Bennée * Having a stop CPU corresponding to a process that is not attached 2814*842b42dfSAlex Bennée * confuses GDB. So we ignore the request. 2815*842b42dfSAlex Bennée */ 2816*842b42dfSAlex Bennée return; 2817*842b42dfSAlex Bennée } 2818*842b42dfSAlex Bennée 2819*842b42dfSAlex Bennée gdbserver_state.c_cpu = cpu; 2820*842b42dfSAlex Bennée gdbserver_state.g_cpu = cpu; 2821*842b42dfSAlex Bennée } 2822*842b42dfSAlex Bennée 2823*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 2824*842b42dfSAlex Bennée static void gdb_vm_state_change(void *opaque, bool running, RunState state) 2825*842b42dfSAlex Bennée { 2826*842b42dfSAlex Bennée CPUState *cpu = gdbserver_state.c_cpu; 2827*842b42dfSAlex Bennée g_autoptr(GString) buf = g_string_new(NULL); 2828*842b42dfSAlex Bennée g_autoptr(GString) tid = g_string_new(NULL); 2829*842b42dfSAlex Bennée const char *type; 2830*842b42dfSAlex Bennée int ret; 2831*842b42dfSAlex Bennée 2832*842b42dfSAlex Bennée if (running || gdbserver_state.state == RS_INACTIVE) { 2833*842b42dfSAlex Bennée return; 2834*842b42dfSAlex Bennée } 2835*842b42dfSAlex Bennée /* Is there a GDB syscall waiting to be sent? */ 2836*842b42dfSAlex Bennée if (gdbserver_state.current_syscall_cb) { 2837*842b42dfSAlex Bennée put_packet(gdbserver_state.syscall_buf); 2838*842b42dfSAlex Bennée return; 2839*842b42dfSAlex Bennée } 2840*842b42dfSAlex Bennée 2841*842b42dfSAlex Bennée if (cpu == NULL) { 2842*842b42dfSAlex Bennée /* No process attached */ 2843*842b42dfSAlex Bennée return; 2844*842b42dfSAlex Bennée } 2845*842b42dfSAlex Bennée 2846*842b42dfSAlex Bennée gdb_append_thread_id(cpu, tid); 2847*842b42dfSAlex Bennée 2848*842b42dfSAlex Bennée switch (state) { 2849*842b42dfSAlex Bennée case RUN_STATE_DEBUG: 2850*842b42dfSAlex Bennée if (cpu->watchpoint_hit) { 2851*842b42dfSAlex Bennée switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) { 2852*842b42dfSAlex Bennée case BP_MEM_READ: 2853*842b42dfSAlex Bennée type = "r"; 2854*842b42dfSAlex Bennée break; 2855*842b42dfSAlex Bennée case BP_MEM_ACCESS: 2856*842b42dfSAlex Bennée type = "a"; 2857*842b42dfSAlex Bennée break; 2858*842b42dfSAlex Bennée default: 2859*842b42dfSAlex Bennée type = ""; 2860*842b42dfSAlex Bennée break; 2861*842b42dfSAlex Bennée } 2862*842b42dfSAlex Bennée trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu), 2863*842b42dfSAlex Bennée (target_ulong)cpu->watchpoint_hit->vaddr); 2864*842b42dfSAlex Bennée g_string_printf(buf, "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";", 2865*842b42dfSAlex Bennée GDB_SIGNAL_TRAP, tid->str, type, 2866*842b42dfSAlex Bennée (target_ulong)cpu->watchpoint_hit->vaddr); 2867*842b42dfSAlex Bennée cpu->watchpoint_hit = NULL; 2868*842b42dfSAlex Bennée goto send_packet; 2869*842b42dfSAlex Bennée } else { 2870*842b42dfSAlex Bennée trace_gdbstub_hit_break(); 2871*842b42dfSAlex Bennée } 2872*842b42dfSAlex Bennée tb_flush(cpu); 2873*842b42dfSAlex Bennée ret = GDB_SIGNAL_TRAP; 2874*842b42dfSAlex Bennée break; 2875*842b42dfSAlex Bennée case RUN_STATE_PAUSED: 2876*842b42dfSAlex Bennée trace_gdbstub_hit_paused(); 2877*842b42dfSAlex Bennée ret = GDB_SIGNAL_INT; 2878*842b42dfSAlex Bennée break; 2879*842b42dfSAlex Bennée case RUN_STATE_SHUTDOWN: 2880*842b42dfSAlex Bennée trace_gdbstub_hit_shutdown(); 2881*842b42dfSAlex Bennée ret = GDB_SIGNAL_QUIT; 2882*842b42dfSAlex Bennée break; 2883*842b42dfSAlex Bennée case RUN_STATE_IO_ERROR: 2884*842b42dfSAlex Bennée trace_gdbstub_hit_io_error(); 2885*842b42dfSAlex Bennée ret = GDB_SIGNAL_IO; 2886*842b42dfSAlex Bennée break; 2887*842b42dfSAlex Bennée case RUN_STATE_WATCHDOG: 2888*842b42dfSAlex Bennée trace_gdbstub_hit_watchdog(); 2889*842b42dfSAlex Bennée ret = GDB_SIGNAL_ALRM; 2890*842b42dfSAlex Bennée break; 2891*842b42dfSAlex Bennée case RUN_STATE_INTERNAL_ERROR: 2892*842b42dfSAlex Bennée trace_gdbstub_hit_internal_error(); 2893*842b42dfSAlex Bennée ret = GDB_SIGNAL_ABRT; 2894*842b42dfSAlex Bennée break; 2895*842b42dfSAlex Bennée case RUN_STATE_SAVE_VM: 2896*842b42dfSAlex Bennée case RUN_STATE_RESTORE_VM: 2897*842b42dfSAlex Bennée return; 2898*842b42dfSAlex Bennée case RUN_STATE_FINISH_MIGRATE: 2899*842b42dfSAlex Bennée ret = GDB_SIGNAL_XCPU; 2900*842b42dfSAlex Bennée break; 2901*842b42dfSAlex Bennée default: 2902*842b42dfSAlex Bennée trace_gdbstub_hit_unknown(state); 2903*842b42dfSAlex Bennée ret = GDB_SIGNAL_UNKNOWN; 2904*842b42dfSAlex Bennée break; 2905*842b42dfSAlex Bennée } 2906*842b42dfSAlex Bennée gdb_set_stop_cpu(cpu); 2907*842b42dfSAlex Bennée g_string_printf(buf, "T%02xthread:%s;", ret, tid->str); 2908*842b42dfSAlex Bennée 2909*842b42dfSAlex Bennée send_packet: 2910*842b42dfSAlex Bennée put_packet(buf->str); 2911*842b42dfSAlex Bennée 2912*842b42dfSAlex Bennée /* disable single step if it was enabled */ 2913*842b42dfSAlex Bennée cpu_single_step(cpu, 0); 2914*842b42dfSAlex Bennée } 2915*842b42dfSAlex Bennée #endif 2916*842b42dfSAlex Bennée 2917*842b42dfSAlex Bennée /* Send a gdb syscall request. 2918*842b42dfSAlex Bennée This accepts limited printf-style format specifiers, specifically: 2919*842b42dfSAlex Bennée %x - target_ulong argument printed in hex. 2920*842b42dfSAlex Bennée %lx - 64-bit argument printed in hex. 2921*842b42dfSAlex Bennée %s - string pointer (target_ulong) and length (int) pair. */ 2922*842b42dfSAlex Bennée void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va) 2923*842b42dfSAlex Bennée { 2924*842b42dfSAlex Bennée char *p; 2925*842b42dfSAlex Bennée char *p_end; 2926*842b42dfSAlex Bennée target_ulong addr; 2927*842b42dfSAlex Bennée uint64_t i64; 2928*842b42dfSAlex Bennée 2929*842b42dfSAlex Bennée if (!gdb_attached()) { 2930*842b42dfSAlex Bennée return; 2931*842b42dfSAlex Bennée } 2932*842b42dfSAlex Bennée 2933*842b42dfSAlex Bennée gdbserver_state.current_syscall_cb = cb; 2934*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 2935*842b42dfSAlex Bennée vm_stop(RUN_STATE_DEBUG); 2936*842b42dfSAlex Bennée #endif 2937*842b42dfSAlex Bennée p = &gdbserver_state.syscall_buf[0]; 2938*842b42dfSAlex Bennée p_end = &gdbserver_state.syscall_buf[sizeof(gdbserver_state.syscall_buf)]; 2939*842b42dfSAlex Bennée *(p++) = 'F'; 2940*842b42dfSAlex Bennée while (*fmt) { 2941*842b42dfSAlex Bennée if (*fmt == '%') { 2942*842b42dfSAlex Bennée fmt++; 2943*842b42dfSAlex Bennée switch (*fmt++) { 2944*842b42dfSAlex Bennée case 'x': 2945*842b42dfSAlex Bennée addr = va_arg(va, target_ulong); 2946*842b42dfSAlex Bennée p += snprintf(p, p_end - p, TARGET_FMT_lx, addr); 2947*842b42dfSAlex Bennée break; 2948*842b42dfSAlex Bennée case 'l': 2949*842b42dfSAlex Bennée if (*(fmt++) != 'x') 2950*842b42dfSAlex Bennée goto bad_format; 2951*842b42dfSAlex Bennée i64 = va_arg(va, uint64_t); 2952*842b42dfSAlex Bennée p += snprintf(p, p_end - p, "%" PRIx64, i64); 2953*842b42dfSAlex Bennée break; 2954*842b42dfSAlex Bennée case 's': 2955*842b42dfSAlex Bennée addr = va_arg(va, target_ulong); 2956*842b42dfSAlex Bennée p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x", 2957*842b42dfSAlex Bennée addr, va_arg(va, int)); 2958*842b42dfSAlex Bennée break; 2959*842b42dfSAlex Bennée default: 2960*842b42dfSAlex Bennée bad_format: 2961*842b42dfSAlex Bennée error_report("gdbstub: Bad syscall format string '%s'", 2962*842b42dfSAlex Bennée fmt - 1); 2963*842b42dfSAlex Bennée break; 2964*842b42dfSAlex Bennée } 2965*842b42dfSAlex Bennée } else { 2966*842b42dfSAlex Bennée *(p++) = *(fmt++); 2967*842b42dfSAlex Bennée } 2968*842b42dfSAlex Bennée } 2969*842b42dfSAlex Bennée *p = 0; 2970*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 2971*842b42dfSAlex Bennée put_packet(gdbserver_state.syscall_buf); 2972*842b42dfSAlex Bennée /* Return control to gdb for it to process the syscall request. 2973*842b42dfSAlex Bennée * Since the protocol requires that gdb hands control back to us 2974*842b42dfSAlex Bennée * using a "here are the results" F packet, we don't need to check 2975*842b42dfSAlex Bennée * gdb_handlesig's return value (which is the signal to deliver if 2976*842b42dfSAlex Bennée * execution was resumed via a continue packet). 2977*842b42dfSAlex Bennée */ 2978*842b42dfSAlex Bennée gdb_handlesig(gdbserver_state.c_cpu, 0); 2979*842b42dfSAlex Bennée #else 2980*842b42dfSAlex Bennée /* In this case wait to send the syscall packet until notification that 2981*842b42dfSAlex Bennée the CPU has stopped. This must be done because if the packet is sent 2982*842b42dfSAlex Bennée now the reply from the syscall request could be received while the CPU 2983*842b42dfSAlex Bennée is still in the running state, which can cause packets to be dropped 2984*842b42dfSAlex Bennée and state transition 'T' packets to be sent while the syscall is still 2985*842b42dfSAlex Bennée being processed. */ 2986*842b42dfSAlex Bennée qemu_cpu_kick(gdbserver_state.c_cpu); 2987*842b42dfSAlex Bennée #endif 2988*842b42dfSAlex Bennée } 2989*842b42dfSAlex Bennée 2990*842b42dfSAlex Bennée void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...) 2991*842b42dfSAlex Bennée { 2992*842b42dfSAlex Bennée va_list va; 2993*842b42dfSAlex Bennée 2994*842b42dfSAlex Bennée va_start(va, fmt); 2995*842b42dfSAlex Bennée gdb_do_syscallv(cb, fmt, va); 2996*842b42dfSAlex Bennée va_end(va); 2997*842b42dfSAlex Bennée } 2998*842b42dfSAlex Bennée 2999*842b42dfSAlex Bennée static void gdb_read_byte(uint8_t ch) 3000*842b42dfSAlex Bennée { 3001*842b42dfSAlex Bennée uint8_t reply; 3002*842b42dfSAlex Bennée 3003*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 3004*842b42dfSAlex Bennée if (gdbserver_state.last_packet->len) { 3005*842b42dfSAlex Bennée /* Waiting for a response to the last packet. If we see the start 3006*842b42dfSAlex Bennée of a new command then abandon the previous response. */ 3007*842b42dfSAlex Bennée if (ch == '-') { 3008*842b42dfSAlex Bennée trace_gdbstub_err_got_nack(); 3009*842b42dfSAlex Bennée put_buffer(gdbserver_state.last_packet->data, 3010*842b42dfSAlex Bennée gdbserver_state.last_packet->len); 3011*842b42dfSAlex Bennée } else if (ch == '+') { 3012*842b42dfSAlex Bennée trace_gdbstub_io_got_ack(); 3013*842b42dfSAlex Bennée } else { 3014*842b42dfSAlex Bennée trace_gdbstub_io_got_unexpected(ch); 3015*842b42dfSAlex Bennée } 3016*842b42dfSAlex Bennée 3017*842b42dfSAlex Bennée if (ch == '+' || ch == '$') { 3018*842b42dfSAlex Bennée g_byte_array_set_size(gdbserver_state.last_packet, 0); 3019*842b42dfSAlex Bennée } 3020*842b42dfSAlex Bennée if (ch != '$') 3021*842b42dfSAlex Bennée return; 3022*842b42dfSAlex Bennée } 3023*842b42dfSAlex Bennée if (runstate_is_running()) { 3024*842b42dfSAlex Bennée /* when the CPU is running, we cannot do anything except stop 3025*842b42dfSAlex Bennée it when receiving a char */ 3026*842b42dfSAlex Bennée vm_stop(RUN_STATE_PAUSED); 3027*842b42dfSAlex Bennée } else 3028*842b42dfSAlex Bennée #endif 3029*842b42dfSAlex Bennée { 3030*842b42dfSAlex Bennée switch(gdbserver_state.state) { 3031*842b42dfSAlex Bennée case RS_IDLE: 3032*842b42dfSAlex Bennée if (ch == '$') { 3033*842b42dfSAlex Bennée /* start of command packet */ 3034*842b42dfSAlex Bennée gdbserver_state.line_buf_index = 0; 3035*842b42dfSAlex Bennée gdbserver_state.line_sum = 0; 3036*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3037*842b42dfSAlex Bennée } else { 3038*842b42dfSAlex Bennée trace_gdbstub_err_garbage(ch); 3039*842b42dfSAlex Bennée } 3040*842b42dfSAlex Bennée break; 3041*842b42dfSAlex Bennée case RS_GETLINE: 3042*842b42dfSAlex Bennée if (ch == '}') { 3043*842b42dfSAlex Bennée /* start escape sequence */ 3044*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE_ESC; 3045*842b42dfSAlex Bennée gdbserver_state.line_sum += ch; 3046*842b42dfSAlex Bennée } else if (ch == '*') { 3047*842b42dfSAlex Bennée /* start run length encoding sequence */ 3048*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE_RLE; 3049*842b42dfSAlex Bennée gdbserver_state.line_sum += ch; 3050*842b42dfSAlex Bennée } else if (ch == '#') { 3051*842b42dfSAlex Bennée /* end of command, start of checksum*/ 3052*842b42dfSAlex Bennée gdbserver_state.state = RS_CHKSUM1; 3053*842b42dfSAlex Bennée } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) { 3054*842b42dfSAlex Bennée trace_gdbstub_err_overrun(); 3055*842b42dfSAlex Bennée gdbserver_state.state = RS_IDLE; 3056*842b42dfSAlex Bennée } else { 3057*842b42dfSAlex Bennée /* unescaped command character */ 3058*842b42dfSAlex Bennée gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch; 3059*842b42dfSAlex Bennée gdbserver_state.line_sum += ch; 3060*842b42dfSAlex Bennée } 3061*842b42dfSAlex Bennée break; 3062*842b42dfSAlex Bennée case RS_GETLINE_ESC: 3063*842b42dfSAlex Bennée if (ch == '#') { 3064*842b42dfSAlex Bennée /* unexpected end of command in escape sequence */ 3065*842b42dfSAlex Bennée gdbserver_state.state = RS_CHKSUM1; 3066*842b42dfSAlex Bennée } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) { 3067*842b42dfSAlex Bennée /* command buffer overrun */ 3068*842b42dfSAlex Bennée trace_gdbstub_err_overrun(); 3069*842b42dfSAlex Bennée gdbserver_state.state = RS_IDLE; 3070*842b42dfSAlex Bennée } else { 3071*842b42dfSAlex Bennée /* parse escaped character and leave escape state */ 3072*842b42dfSAlex Bennée gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20; 3073*842b42dfSAlex Bennée gdbserver_state.line_sum += ch; 3074*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3075*842b42dfSAlex Bennée } 3076*842b42dfSAlex Bennée break; 3077*842b42dfSAlex Bennée case RS_GETLINE_RLE: 3078*842b42dfSAlex Bennée /* 3079*842b42dfSAlex Bennée * Run-length encoding is explained in "Debugging with GDB / 3080*842b42dfSAlex Bennée * Appendix E GDB Remote Serial Protocol / Overview". 3081*842b42dfSAlex Bennée */ 3082*842b42dfSAlex Bennée if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) { 3083*842b42dfSAlex Bennée /* invalid RLE count encoding */ 3084*842b42dfSAlex Bennée trace_gdbstub_err_invalid_repeat(ch); 3085*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3086*842b42dfSAlex Bennée } else { 3087*842b42dfSAlex Bennée /* decode repeat length */ 3088*842b42dfSAlex Bennée int repeat = ch - ' ' + 3; 3089*842b42dfSAlex Bennée if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) { 3090*842b42dfSAlex Bennée /* that many repeats would overrun the command buffer */ 3091*842b42dfSAlex Bennée trace_gdbstub_err_overrun(); 3092*842b42dfSAlex Bennée gdbserver_state.state = RS_IDLE; 3093*842b42dfSAlex Bennée } else if (gdbserver_state.line_buf_index < 1) { 3094*842b42dfSAlex Bennée /* got a repeat but we have nothing to repeat */ 3095*842b42dfSAlex Bennée trace_gdbstub_err_invalid_rle(); 3096*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3097*842b42dfSAlex Bennée } else { 3098*842b42dfSAlex Bennée /* repeat the last character */ 3099*842b42dfSAlex Bennée memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index, 3100*842b42dfSAlex Bennée gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat); 3101*842b42dfSAlex Bennée gdbserver_state.line_buf_index += repeat; 3102*842b42dfSAlex Bennée gdbserver_state.line_sum += ch; 3103*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3104*842b42dfSAlex Bennée } 3105*842b42dfSAlex Bennée } 3106*842b42dfSAlex Bennée break; 3107*842b42dfSAlex Bennée case RS_CHKSUM1: 3108*842b42dfSAlex Bennée /* get high hex digit of checksum */ 3109*842b42dfSAlex Bennée if (!isxdigit(ch)) { 3110*842b42dfSAlex Bennée trace_gdbstub_err_checksum_invalid(ch); 3111*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3112*842b42dfSAlex Bennée break; 3113*842b42dfSAlex Bennée } 3114*842b42dfSAlex Bennée gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0'; 3115*842b42dfSAlex Bennée gdbserver_state.line_csum = fromhex(ch) << 4; 3116*842b42dfSAlex Bennée gdbserver_state.state = RS_CHKSUM2; 3117*842b42dfSAlex Bennée break; 3118*842b42dfSAlex Bennée case RS_CHKSUM2: 3119*842b42dfSAlex Bennée /* get low hex digit of checksum */ 3120*842b42dfSAlex Bennée if (!isxdigit(ch)) { 3121*842b42dfSAlex Bennée trace_gdbstub_err_checksum_invalid(ch); 3122*842b42dfSAlex Bennée gdbserver_state.state = RS_GETLINE; 3123*842b42dfSAlex Bennée break; 3124*842b42dfSAlex Bennée } 3125*842b42dfSAlex Bennée gdbserver_state.line_csum |= fromhex(ch); 3126*842b42dfSAlex Bennée 3127*842b42dfSAlex Bennée if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) { 3128*842b42dfSAlex Bennée trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum); 3129*842b42dfSAlex Bennée /* send NAK reply */ 3130*842b42dfSAlex Bennée reply = '-'; 3131*842b42dfSAlex Bennée put_buffer(&reply, 1); 3132*842b42dfSAlex Bennée gdbserver_state.state = RS_IDLE; 3133*842b42dfSAlex Bennée } else { 3134*842b42dfSAlex Bennée /* send ACK reply */ 3135*842b42dfSAlex Bennée reply = '+'; 3136*842b42dfSAlex Bennée put_buffer(&reply, 1); 3137*842b42dfSAlex Bennée gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf); 3138*842b42dfSAlex Bennée } 3139*842b42dfSAlex Bennée break; 3140*842b42dfSAlex Bennée default: 3141*842b42dfSAlex Bennée abort(); 3142*842b42dfSAlex Bennée } 3143*842b42dfSAlex Bennée } 3144*842b42dfSAlex Bennée } 3145*842b42dfSAlex Bennée 3146*842b42dfSAlex Bennée /* Tell the remote gdb that the process has exited. */ 3147*842b42dfSAlex Bennée void gdb_exit(int code) 3148*842b42dfSAlex Bennée { 3149*842b42dfSAlex Bennée char buf[4]; 3150*842b42dfSAlex Bennée 3151*842b42dfSAlex Bennée if (!gdbserver_state.init) { 3152*842b42dfSAlex Bennée return; 3153*842b42dfSAlex Bennée } 3154*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 3155*842b42dfSAlex Bennée if (gdbserver_state.socket_path) { 3156*842b42dfSAlex Bennée unlink(gdbserver_state.socket_path); 3157*842b42dfSAlex Bennée } 3158*842b42dfSAlex Bennée if (gdbserver_state.fd < 0) { 3159*842b42dfSAlex Bennée return; 3160*842b42dfSAlex Bennée } 3161*842b42dfSAlex Bennée #endif 3162*842b42dfSAlex Bennée 3163*842b42dfSAlex Bennée trace_gdbstub_op_exiting((uint8_t)code); 3164*842b42dfSAlex Bennée 3165*842b42dfSAlex Bennée snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code); 3166*842b42dfSAlex Bennée put_packet(buf); 3167*842b42dfSAlex Bennée 3168*842b42dfSAlex Bennée #ifndef CONFIG_USER_ONLY 3169*842b42dfSAlex Bennée qemu_chr_fe_deinit(&gdbserver_state.chr, true); 3170*842b42dfSAlex Bennée #endif 3171*842b42dfSAlex Bennée } 3172*842b42dfSAlex Bennée 3173*842b42dfSAlex Bennée /* 3174*842b42dfSAlex Bennée * Create the process that will contain all the "orphan" CPUs (that are not 3175*842b42dfSAlex Bennée * part of a CPU cluster). Note that if this process contains no CPUs, it won't 3176*842b42dfSAlex Bennée * be attachable and thus will be invisible to the user. 3177*842b42dfSAlex Bennée */ 3178*842b42dfSAlex Bennée static void create_default_process(GDBState *s) 3179*842b42dfSAlex Bennée { 3180*842b42dfSAlex Bennée GDBProcess *process; 3181*842b42dfSAlex Bennée int max_pid = 0; 3182*842b42dfSAlex Bennée 3183*842b42dfSAlex Bennée if (gdbserver_state.process_num) { 3184*842b42dfSAlex Bennée max_pid = s->processes[s->process_num - 1].pid; 3185*842b42dfSAlex Bennée } 3186*842b42dfSAlex Bennée 3187*842b42dfSAlex Bennée s->processes = g_renew(GDBProcess, s->processes, ++s->process_num); 3188*842b42dfSAlex Bennée process = &s->processes[s->process_num - 1]; 3189*842b42dfSAlex Bennée 3190*842b42dfSAlex Bennée /* We need an available PID slot for this process */ 3191*842b42dfSAlex Bennée assert(max_pid < UINT32_MAX); 3192*842b42dfSAlex Bennée 3193*842b42dfSAlex Bennée process->pid = max_pid + 1; 3194*842b42dfSAlex Bennée process->attached = false; 3195*842b42dfSAlex Bennée process->target_xml[0] = '\0'; 3196*842b42dfSAlex Bennée } 3197*842b42dfSAlex Bennée 3198*842b42dfSAlex Bennée #ifdef CONFIG_USER_ONLY 3199*842b42dfSAlex Bennée int 3200*842b42dfSAlex Bennée gdb_handlesig(CPUState *cpu, int sig) 3201*842b42dfSAlex Bennée { 3202*842b42dfSAlex Bennée char buf[256]; 3203*842b42dfSAlex Bennée int n; 3204*842b42dfSAlex Bennée 3205*842b42dfSAlex Bennée if (!gdbserver_state.init || gdbserver_state.fd < 0) { 3206*842b42dfSAlex Bennée return sig; 3207*842b42dfSAlex Bennée } 3208*842b42dfSAlex Bennée 3209*842b42dfSAlex Bennée /* disable single step if it was enabled */ 3210*842b42dfSAlex Bennée cpu_single_step(cpu, 0); 3211*842b42dfSAlex Bennée tb_flush(cpu); 3212*842b42dfSAlex Bennée 3213*842b42dfSAlex Bennée if (sig != 0) { 3214*842b42dfSAlex Bennée gdb_set_stop_cpu(cpu); 3215*842b42dfSAlex Bennée g_string_printf(gdbserver_state.str_buf, 3216*842b42dfSAlex Bennée "T%02xthread:", target_signal_to_gdb(sig)); 3217*842b42dfSAlex Bennée gdb_append_thread_id(cpu, gdbserver_state.str_buf); 3218*842b42dfSAlex Bennée g_string_append_c(gdbserver_state.str_buf, ';'); 3219*842b42dfSAlex Bennée put_strbuf(); 3220*842b42dfSAlex Bennée } 3221*842b42dfSAlex Bennée /* put_packet() might have detected that the peer terminated the 3222*842b42dfSAlex Bennée connection. */ 3223*842b42dfSAlex Bennée if (gdbserver_state.fd < 0) { 3224*842b42dfSAlex Bennée return sig; 3225*842b42dfSAlex Bennée } 3226*842b42dfSAlex Bennée 3227*842b42dfSAlex Bennée sig = 0; 3228*842b42dfSAlex Bennée gdbserver_state.state = RS_IDLE; 3229*842b42dfSAlex Bennée gdbserver_state.running_state = 0; 3230*842b42dfSAlex Bennée while (gdbserver_state.running_state == 0) { 3231*842b42dfSAlex Bennée n = read(gdbserver_state.fd, buf, 256); 3232*842b42dfSAlex Bennée if (n > 0) { 3233*842b42dfSAlex Bennée int i; 3234*842b42dfSAlex Bennée 3235*842b42dfSAlex Bennée for (i = 0; i < n; i++) { 3236*842b42dfSAlex Bennée gdb_read_byte(buf[i]); 3237*842b42dfSAlex Bennée } 3238*842b42dfSAlex Bennée } else { 3239*842b42dfSAlex Bennée /* XXX: Connection closed. Should probably wait for another 3240*842b42dfSAlex Bennée connection before continuing. */ 3241*842b42dfSAlex Bennée if (n == 0) { 3242*842b42dfSAlex Bennée close(gdbserver_state.fd); 3243*842b42dfSAlex Bennée } 3244*842b42dfSAlex Bennée gdbserver_state.fd = -1; 3245*842b42dfSAlex Bennée return sig; 3246*842b42dfSAlex Bennée } 3247*842b42dfSAlex Bennée } 3248*842b42dfSAlex Bennée sig = gdbserver_state.signal; 3249*842b42dfSAlex Bennée gdbserver_state.signal = 0; 3250*842b42dfSAlex Bennée return sig; 3251*842b42dfSAlex Bennée } 3252*842b42dfSAlex Bennée 3253*842b42dfSAlex Bennée /* Tell the remote gdb that the process has exited due to SIG. */ 3254*842b42dfSAlex Bennée void gdb_signalled(CPUArchState *env, int sig) 3255*842b42dfSAlex Bennée { 3256*842b42dfSAlex Bennée char buf[4]; 3257*842b42dfSAlex Bennée 3258*842b42dfSAlex Bennée if (!gdbserver_state.init || gdbserver_state.fd < 0) { 3259*842b42dfSAlex Bennée return; 3260*842b42dfSAlex Bennée } 3261*842b42dfSAlex Bennée 3262*842b42dfSAlex Bennée snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig)); 3263*842b42dfSAlex Bennée put_packet(buf); 3264*842b42dfSAlex Bennée } 3265*842b42dfSAlex Bennée 3266*842b42dfSAlex Bennée static void gdb_accept_init(int fd) 3267*842b42dfSAlex Bennée { 3268*842b42dfSAlex Bennée init_gdbserver_state(); 3269*842b42dfSAlex Bennée create_default_process(&gdbserver_state); 3270*842b42dfSAlex Bennée gdbserver_state.processes[0].attached = true; 3271*842b42dfSAlex Bennée gdbserver_state.c_cpu = gdb_first_attached_cpu(); 3272*842b42dfSAlex Bennée gdbserver_state.g_cpu = gdbserver_state.c_cpu; 3273*842b42dfSAlex Bennée gdbserver_state.fd = fd; 3274*842b42dfSAlex Bennée gdb_has_xml = false; 3275*842b42dfSAlex Bennée } 3276*842b42dfSAlex Bennée 3277*842b42dfSAlex Bennée static bool gdb_accept_socket(int gdb_fd) 3278*842b42dfSAlex Bennée { 3279*842b42dfSAlex Bennée int fd; 3280*842b42dfSAlex Bennée 3281*842b42dfSAlex Bennée for(;;) { 3282*842b42dfSAlex Bennée fd = accept(gdb_fd, NULL, NULL); 3283*842b42dfSAlex Bennée if (fd < 0 && errno != EINTR) { 3284*842b42dfSAlex Bennée perror("accept socket"); 3285*842b42dfSAlex Bennée return false; 3286*842b42dfSAlex Bennée } else if (fd >= 0) { 3287*842b42dfSAlex Bennée qemu_set_cloexec(fd); 3288*842b42dfSAlex Bennée break; 3289*842b42dfSAlex Bennée } 3290*842b42dfSAlex Bennée } 3291*842b42dfSAlex Bennée 3292*842b42dfSAlex Bennée gdb_accept_init(fd); 3293*842b42dfSAlex Bennée return true; 3294*842b42dfSAlex Bennée } 3295*842b42dfSAlex Bennée 3296*842b42dfSAlex Bennée static int gdbserver_open_socket(const char *path) 3297*842b42dfSAlex Bennée { 3298*842b42dfSAlex Bennée struct sockaddr_un sockaddr = {}; 3299*842b42dfSAlex Bennée int fd, ret; 3300*842b42dfSAlex Bennée 3301*842b42dfSAlex Bennée fd = socket(AF_UNIX, SOCK_STREAM, 0); 3302*842b42dfSAlex Bennée if (fd < 0) { 3303*842b42dfSAlex Bennée perror("create socket"); 3304*842b42dfSAlex Bennée return -1; 3305*842b42dfSAlex Bennée } 3306*842b42dfSAlex Bennée 3307*842b42dfSAlex Bennée sockaddr.sun_family = AF_UNIX; 3308*842b42dfSAlex Bennée pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path); 3309*842b42dfSAlex Bennée ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)); 3310*842b42dfSAlex Bennée if (ret < 0) { 3311*842b42dfSAlex Bennée perror("bind socket"); 3312*842b42dfSAlex Bennée close(fd); 3313*842b42dfSAlex Bennée return -1; 3314*842b42dfSAlex Bennée } 3315*842b42dfSAlex Bennée ret = listen(fd, 1); 3316*842b42dfSAlex Bennée if (ret < 0) { 3317*842b42dfSAlex Bennée perror("listen socket"); 3318*842b42dfSAlex Bennée close(fd); 3319*842b42dfSAlex Bennée return -1; 3320*842b42dfSAlex Bennée } 3321*842b42dfSAlex Bennée 3322*842b42dfSAlex Bennée return fd; 3323*842b42dfSAlex Bennée } 3324*842b42dfSAlex Bennée 3325*842b42dfSAlex Bennée static bool gdb_accept_tcp(int gdb_fd) 3326*842b42dfSAlex Bennée { 3327*842b42dfSAlex Bennée struct sockaddr_in sockaddr = {}; 3328*842b42dfSAlex Bennée socklen_t len; 3329*842b42dfSAlex Bennée int fd; 3330*842b42dfSAlex Bennée 3331*842b42dfSAlex Bennée for(;;) { 3332*842b42dfSAlex Bennée len = sizeof(sockaddr); 3333*842b42dfSAlex Bennée fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len); 3334*842b42dfSAlex Bennée if (fd < 0 && errno != EINTR) { 3335*842b42dfSAlex Bennée perror("accept"); 3336*842b42dfSAlex Bennée return false; 3337*842b42dfSAlex Bennée } else if (fd >= 0) { 3338*842b42dfSAlex Bennée qemu_set_cloexec(fd); 3339*842b42dfSAlex Bennée break; 3340*842b42dfSAlex Bennée } 3341*842b42dfSAlex Bennée } 3342*842b42dfSAlex Bennée 3343*842b42dfSAlex Bennée /* set short latency */ 3344*842b42dfSAlex Bennée if (socket_set_nodelay(fd)) { 3345*842b42dfSAlex Bennée perror("setsockopt"); 3346*842b42dfSAlex Bennée close(fd); 3347*842b42dfSAlex Bennée return false; 3348*842b42dfSAlex Bennée } 3349*842b42dfSAlex Bennée 3350*842b42dfSAlex Bennée gdb_accept_init(fd); 3351*842b42dfSAlex Bennée return true; 3352*842b42dfSAlex Bennée } 3353*842b42dfSAlex Bennée 3354*842b42dfSAlex Bennée static int gdbserver_open_port(int port) 3355*842b42dfSAlex Bennée { 3356*842b42dfSAlex Bennée struct sockaddr_in sockaddr; 3357*842b42dfSAlex Bennée int fd, ret; 3358*842b42dfSAlex Bennée 3359*842b42dfSAlex Bennée fd = socket(PF_INET, SOCK_STREAM, 0); 3360*842b42dfSAlex Bennée if (fd < 0) { 3361*842b42dfSAlex Bennée perror("socket"); 3362*842b42dfSAlex Bennée return -1; 3363*842b42dfSAlex Bennée } 3364*842b42dfSAlex Bennée qemu_set_cloexec(fd); 3365*842b42dfSAlex Bennée 3366*842b42dfSAlex Bennée socket_set_fast_reuse(fd); 3367*842b42dfSAlex Bennée 3368*842b42dfSAlex Bennée sockaddr.sin_family = AF_INET; 3369*842b42dfSAlex Bennée sockaddr.sin_port = htons(port); 3370*842b42dfSAlex Bennée sockaddr.sin_addr.s_addr = 0; 3371*842b42dfSAlex Bennée ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)); 3372*842b42dfSAlex Bennée if (ret < 0) { 3373*842b42dfSAlex Bennée perror("bind"); 3374*842b42dfSAlex Bennée close(fd); 3375*842b42dfSAlex Bennée return -1; 3376*842b42dfSAlex Bennée } 3377*842b42dfSAlex Bennée ret = listen(fd, 1); 3378*842b42dfSAlex Bennée if (ret < 0) { 3379*842b42dfSAlex Bennée perror("listen"); 3380*842b42dfSAlex Bennée close(fd); 3381*842b42dfSAlex Bennée return -1; 3382*842b42dfSAlex Bennée } 3383*842b42dfSAlex Bennée 3384*842b42dfSAlex Bennée return fd; 3385*842b42dfSAlex Bennée } 3386*842b42dfSAlex Bennée 3387*842b42dfSAlex Bennée int gdbserver_start(const char *port_or_path) 3388*842b42dfSAlex Bennée { 3389*842b42dfSAlex Bennée int port = g_ascii_strtoull(port_or_path, NULL, 10); 3390*842b42dfSAlex Bennée int gdb_fd; 3391*842b42dfSAlex Bennée 3392*842b42dfSAlex Bennée if (port > 0) { 3393*842b42dfSAlex Bennée gdb_fd = gdbserver_open_port(port); 3394*842b42dfSAlex Bennée } else { 3395*842b42dfSAlex Bennée gdb_fd = gdbserver_open_socket(port_or_path); 3396*842b42dfSAlex Bennée } 3397*842b42dfSAlex Bennée 3398*842b42dfSAlex Bennée if (gdb_fd < 0) { 3399*842b42dfSAlex Bennée return -1; 3400*842b42dfSAlex Bennée } 3401*842b42dfSAlex Bennée 3402*842b42dfSAlex Bennée if (port > 0 && gdb_accept_tcp(gdb_fd)) { 3403*842b42dfSAlex Bennée return 0; 3404*842b42dfSAlex Bennée } else if (gdb_accept_socket(gdb_fd)) { 3405*842b42dfSAlex Bennée gdbserver_state.socket_path = g_strdup(port_or_path); 3406*842b42dfSAlex Bennée return 0; 3407*842b42dfSAlex Bennée } 3408*842b42dfSAlex Bennée 3409*842b42dfSAlex Bennée /* gone wrong */ 3410*842b42dfSAlex Bennée close(gdb_fd); 3411*842b42dfSAlex Bennée return -1; 3412*842b42dfSAlex Bennée } 3413*842b42dfSAlex Bennée 3414*842b42dfSAlex Bennée /* Disable gdb stub for child processes. */ 3415*842b42dfSAlex Bennée void gdbserver_fork(CPUState *cpu) 3416*842b42dfSAlex Bennée { 3417*842b42dfSAlex Bennée if (!gdbserver_state.init || gdbserver_state.fd < 0) { 3418*842b42dfSAlex Bennée return; 3419*842b42dfSAlex Bennée } 3420*842b42dfSAlex Bennée close(gdbserver_state.fd); 3421*842b42dfSAlex Bennée gdbserver_state.fd = -1; 3422*842b42dfSAlex Bennée cpu_breakpoint_remove_all(cpu, BP_GDB); 3423*842b42dfSAlex Bennée cpu_watchpoint_remove_all(cpu, BP_GDB); 3424*842b42dfSAlex Bennée } 3425*842b42dfSAlex Bennée #else 3426*842b42dfSAlex Bennée static int gdb_chr_can_receive(void *opaque) 3427*842b42dfSAlex Bennée { 3428*842b42dfSAlex Bennée /* We can handle an arbitrarily large amount of data. 3429*842b42dfSAlex Bennée Pick the maximum packet size, which is as good as anything. */ 3430*842b42dfSAlex Bennée return MAX_PACKET_LENGTH; 3431*842b42dfSAlex Bennée } 3432*842b42dfSAlex Bennée 3433*842b42dfSAlex Bennée static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size) 3434*842b42dfSAlex Bennée { 3435*842b42dfSAlex Bennée int i; 3436*842b42dfSAlex Bennée 3437*842b42dfSAlex Bennée for (i = 0; i < size; i++) { 3438*842b42dfSAlex Bennée gdb_read_byte(buf[i]); 3439*842b42dfSAlex Bennée } 3440*842b42dfSAlex Bennée } 3441*842b42dfSAlex Bennée 3442*842b42dfSAlex Bennée static void gdb_chr_event(void *opaque, QEMUChrEvent event) 3443*842b42dfSAlex Bennée { 3444*842b42dfSAlex Bennée int i; 3445*842b42dfSAlex Bennée GDBState *s = (GDBState *) opaque; 3446*842b42dfSAlex Bennée 3447*842b42dfSAlex Bennée switch (event) { 3448*842b42dfSAlex Bennée case CHR_EVENT_OPENED: 3449*842b42dfSAlex Bennée /* Start with first process attached, others detached */ 3450*842b42dfSAlex Bennée for (i = 0; i < s->process_num; i++) { 3451*842b42dfSAlex Bennée s->processes[i].attached = !i; 3452*842b42dfSAlex Bennée } 3453*842b42dfSAlex Bennée 3454*842b42dfSAlex Bennée s->c_cpu = gdb_first_attached_cpu(); 3455*842b42dfSAlex Bennée s->g_cpu = s->c_cpu; 3456*842b42dfSAlex Bennée 3457*842b42dfSAlex Bennée vm_stop(RUN_STATE_PAUSED); 3458*842b42dfSAlex Bennée replay_gdb_attached(); 3459*842b42dfSAlex Bennée gdb_has_xml = false; 3460*842b42dfSAlex Bennée break; 3461*842b42dfSAlex Bennée default: 3462*842b42dfSAlex Bennée break; 3463*842b42dfSAlex Bennée } 3464*842b42dfSAlex Bennée } 3465*842b42dfSAlex Bennée 3466*842b42dfSAlex Bennée static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len) 3467*842b42dfSAlex Bennée { 3468*842b42dfSAlex Bennée g_autoptr(GString) hex_buf = g_string_new("O"); 3469*842b42dfSAlex Bennée memtohex(hex_buf, buf, len); 3470*842b42dfSAlex Bennée put_packet(hex_buf->str); 3471*842b42dfSAlex Bennée return len; 3472*842b42dfSAlex Bennée } 3473*842b42dfSAlex Bennée 3474*842b42dfSAlex Bennée #ifndef _WIN32 3475*842b42dfSAlex Bennée static void gdb_sigterm_handler(int signal) 3476*842b42dfSAlex Bennée { 3477*842b42dfSAlex Bennée if (runstate_is_running()) { 3478*842b42dfSAlex Bennée vm_stop(RUN_STATE_PAUSED); 3479*842b42dfSAlex Bennée } 3480*842b42dfSAlex Bennée } 3481*842b42dfSAlex Bennée #endif 3482*842b42dfSAlex Bennée 3483*842b42dfSAlex Bennée static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend, 3484*842b42dfSAlex Bennée bool *be_opened, Error **errp) 3485*842b42dfSAlex Bennée { 3486*842b42dfSAlex Bennée *be_opened = false; 3487*842b42dfSAlex Bennée } 3488*842b42dfSAlex Bennée 3489*842b42dfSAlex Bennée static void char_gdb_class_init(ObjectClass *oc, void *data) 3490*842b42dfSAlex Bennée { 3491*842b42dfSAlex Bennée ChardevClass *cc = CHARDEV_CLASS(oc); 3492*842b42dfSAlex Bennée 3493*842b42dfSAlex Bennée cc->internal = true; 3494*842b42dfSAlex Bennée cc->open = gdb_monitor_open; 3495*842b42dfSAlex Bennée cc->chr_write = gdb_monitor_write; 3496*842b42dfSAlex Bennée } 3497*842b42dfSAlex Bennée 3498*842b42dfSAlex Bennée #define TYPE_CHARDEV_GDB "chardev-gdb" 3499*842b42dfSAlex Bennée 3500*842b42dfSAlex Bennée static const TypeInfo char_gdb_type_info = { 3501*842b42dfSAlex Bennée .name = TYPE_CHARDEV_GDB, 3502*842b42dfSAlex Bennée .parent = TYPE_CHARDEV, 3503*842b42dfSAlex Bennée .class_init = char_gdb_class_init, 3504*842b42dfSAlex Bennée }; 3505*842b42dfSAlex Bennée 3506*842b42dfSAlex Bennée static int find_cpu_clusters(Object *child, void *opaque) 3507*842b42dfSAlex Bennée { 3508*842b42dfSAlex Bennée if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) { 3509*842b42dfSAlex Bennée GDBState *s = (GDBState *) opaque; 3510*842b42dfSAlex Bennée CPUClusterState *cluster = CPU_CLUSTER(child); 3511*842b42dfSAlex Bennée GDBProcess *process; 3512*842b42dfSAlex Bennée 3513*842b42dfSAlex Bennée s->processes = g_renew(GDBProcess, s->processes, ++s->process_num); 3514*842b42dfSAlex Bennée 3515*842b42dfSAlex Bennée process = &s->processes[s->process_num - 1]; 3516*842b42dfSAlex Bennée 3517*842b42dfSAlex Bennée /* 3518*842b42dfSAlex Bennée * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at 3519*842b42dfSAlex Bennée * runtime, we enforce here that the machine does not use a cluster ID 3520*842b42dfSAlex Bennée * that would lead to PID 0. 3521*842b42dfSAlex Bennée */ 3522*842b42dfSAlex Bennée assert(cluster->cluster_id != UINT32_MAX); 3523*842b42dfSAlex Bennée process->pid = cluster->cluster_id + 1; 3524*842b42dfSAlex Bennée process->attached = false; 3525*842b42dfSAlex Bennée process->target_xml[0] = '\0'; 3526*842b42dfSAlex Bennée 3527*842b42dfSAlex Bennée return 0; 3528*842b42dfSAlex Bennée } 3529*842b42dfSAlex Bennée 3530*842b42dfSAlex Bennée return object_child_foreach(child, find_cpu_clusters, opaque); 3531*842b42dfSAlex Bennée } 3532*842b42dfSAlex Bennée 3533*842b42dfSAlex Bennée static int pid_order(const void *a, const void *b) 3534*842b42dfSAlex Bennée { 3535*842b42dfSAlex Bennée GDBProcess *pa = (GDBProcess *) a; 3536*842b42dfSAlex Bennée GDBProcess *pb = (GDBProcess *) b; 3537*842b42dfSAlex Bennée 3538*842b42dfSAlex Bennée if (pa->pid < pb->pid) { 3539*842b42dfSAlex Bennée return -1; 3540*842b42dfSAlex Bennée } else if (pa->pid > pb->pid) { 3541*842b42dfSAlex Bennée return 1; 3542*842b42dfSAlex Bennée } else { 3543*842b42dfSAlex Bennée return 0; 3544*842b42dfSAlex Bennée } 3545*842b42dfSAlex Bennée } 3546*842b42dfSAlex Bennée 3547*842b42dfSAlex Bennée static void create_processes(GDBState *s) 3548*842b42dfSAlex Bennée { 3549*842b42dfSAlex Bennée object_child_foreach(object_get_root(), find_cpu_clusters, s); 3550*842b42dfSAlex Bennée 3551*842b42dfSAlex Bennée if (gdbserver_state.processes) { 3552*842b42dfSAlex Bennée /* Sort by PID */ 3553*842b42dfSAlex Bennée qsort(gdbserver_state.processes, gdbserver_state.process_num, sizeof(gdbserver_state.processes[0]), pid_order); 3554*842b42dfSAlex Bennée } 3555*842b42dfSAlex Bennée 3556*842b42dfSAlex Bennée create_default_process(s); 3557*842b42dfSAlex Bennée } 3558*842b42dfSAlex Bennée 3559*842b42dfSAlex Bennée int gdbserver_start(const char *device) 3560*842b42dfSAlex Bennée { 3561*842b42dfSAlex Bennée trace_gdbstub_op_start(device); 3562*842b42dfSAlex Bennée 3563*842b42dfSAlex Bennée char gdbstub_device_name[128]; 3564*842b42dfSAlex Bennée Chardev *chr = NULL; 3565*842b42dfSAlex Bennée Chardev *mon_chr; 3566*842b42dfSAlex Bennée 3567*842b42dfSAlex Bennée if (!first_cpu) { 3568*842b42dfSAlex Bennée error_report("gdbstub: meaningless to attach gdb to a " 3569*842b42dfSAlex Bennée "machine without any CPU."); 3570*842b42dfSAlex Bennée return -1; 3571*842b42dfSAlex Bennée } 3572*842b42dfSAlex Bennée 3573*842b42dfSAlex Bennée if (kvm_enabled() && !kvm_supports_guest_debug()) { 3574*842b42dfSAlex Bennée error_report("gdbstub: KVM doesn't support guest debugging"); 3575*842b42dfSAlex Bennée return -1; 3576*842b42dfSAlex Bennée } 3577*842b42dfSAlex Bennée 3578*842b42dfSAlex Bennée if (!device) 3579*842b42dfSAlex Bennée return -1; 3580*842b42dfSAlex Bennée if (strcmp(device, "none") != 0) { 3581*842b42dfSAlex Bennée if (strstart(device, "tcp:", NULL)) { 3582*842b42dfSAlex Bennée /* enforce required TCP attributes */ 3583*842b42dfSAlex Bennée snprintf(gdbstub_device_name, sizeof(gdbstub_device_name), 3584*842b42dfSAlex Bennée "%s,wait=off,nodelay=on,server=on", device); 3585*842b42dfSAlex Bennée device = gdbstub_device_name; 3586*842b42dfSAlex Bennée } 3587*842b42dfSAlex Bennée #ifndef _WIN32 3588*842b42dfSAlex Bennée else if (strcmp(device, "stdio") == 0) { 3589*842b42dfSAlex Bennée struct sigaction act; 3590*842b42dfSAlex Bennée 3591*842b42dfSAlex Bennée memset(&act, 0, sizeof(act)); 3592*842b42dfSAlex Bennée act.sa_handler = gdb_sigterm_handler; 3593*842b42dfSAlex Bennée sigaction(SIGINT, &act, NULL); 3594*842b42dfSAlex Bennée } 3595*842b42dfSAlex Bennée #endif 3596*842b42dfSAlex Bennée /* 3597*842b42dfSAlex Bennée * FIXME: it's a bit weird to allow using a mux chardev here 3598*842b42dfSAlex Bennée * and implicitly setup a monitor. We may want to break this. 3599*842b42dfSAlex Bennée */ 3600*842b42dfSAlex Bennée chr = qemu_chr_new_noreplay("gdb", device, true, NULL); 3601*842b42dfSAlex Bennée if (!chr) 3602*842b42dfSAlex Bennée return -1; 3603*842b42dfSAlex Bennée } 3604*842b42dfSAlex Bennée 3605*842b42dfSAlex Bennée if (!gdbserver_state.init) { 3606*842b42dfSAlex Bennée init_gdbserver_state(); 3607*842b42dfSAlex Bennée 3608*842b42dfSAlex Bennée qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL); 3609*842b42dfSAlex Bennée 3610*842b42dfSAlex Bennée /* Initialize a monitor terminal for gdb */ 3611*842b42dfSAlex Bennée mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB, 3612*842b42dfSAlex Bennée NULL, NULL, &error_abort); 3613*842b42dfSAlex Bennée monitor_init_hmp(mon_chr, false, &error_abort); 3614*842b42dfSAlex Bennée } else { 3615*842b42dfSAlex Bennée qemu_chr_fe_deinit(&gdbserver_state.chr, true); 3616*842b42dfSAlex Bennée mon_chr = gdbserver_state.mon_chr; 3617*842b42dfSAlex Bennée reset_gdbserver_state(); 3618*842b42dfSAlex Bennée } 3619*842b42dfSAlex Bennée 3620*842b42dfSAlex Bennée create_processes(&gdbserver_state); 3621*842b42dfSAlex Bennée 3622*842b42dfSAlex Bennée if (chr) { 3623*842b42dfSAlex Bennée qemu_chr_fe_init(&gdbserver_state.chr, chr, &error_abort); 3624*842b42dfSAlex Bennée qemu_chr_fe_set_handlers(&gdbserver_state.chr, gdb_chr_can_receive, 3625*842b42dfSAlex Bennée gdb_chr_receive, gdb_chr_event, 3626*842b42dfSAlex Bennée NULL, &gdbserver_state, NULL, true); 3627*842b42dfSAlex Bennée } 3628*842b42dfSAlex Bennée gdbserver_state.state = chr ? RS_IDLE : RS_INACTIVE; 3629*842b42dfSAlex Bennée gdbserver_state.mon_chr = mon_chr; 3630*842b42dfSAlex Bennée gdbserver_state.current_syscall_cb = NULL; 3631*842b42dfSAlex Bennée 3632*842b42dfSAlex Bennée return 0; 3633*842b42dfSAlex Bennée } 3634*842b42dfSAlex Bennée 3635*842b42dfSAlex Bennée static void register_types(void) 3636*842b42dfSAlex Bennée { 3637*842b42dfSAlex Bennée type_register_static(&char_gdb_type_info); 3638*842b42dfSAlex Bennée } 3639*842b42dfSAlex Bennée 3640*842b42dfSAlex Bennée type_init(register_types); 3641*842b42dfSAlex Bennée #endif 3642