1 /* Common definitions for remote server for GDB. 2 Copyright (C) 1993, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 3 2006, 2012 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 It has been modified to integrate it in valgrind 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street, Fifth Floor, 22 Boston, MA 02110-1301, USA. */ 23 24 #ifndef SERVER_H 25 #define SERVER_H 26 27 #include "pub_core_basics.h" 28 #include "pub_core_vki.h" 29 #include "pub_core_xarray.h" 30 #include "pub_core_clientstate.h" 31 #include "pub_core_debuglog.h" 32 #include "pub_core_errormgr.h" 33 #include "pub_core_libcassert.h" 34 #include "pub_core_libcfile.h" 35 #include "pub_core_libcprint.h" 36 #include "pub_core_mallocfree.h" 37 #include "pub_core_syscall.h" 38 #include "pub_core_libcproc.h" 39 #include "pub_core_tooliface.h" 40 #include "pub_core_libcassert.h" 41 #include "pub_core_libcbase.h" 42 #include "pub_core_options.h" 43 #include "pub_core_threadstate.h" 44 #include "pub_core_gdbserver.h" 45 #include "pub_core_vki.h" 46 #include "pub_core_clreq.h" 47 48 /*------------- interface m_gdbserver <=> low level gdbserver */ 49 50 /* Initializes gdbserver. After a call to gdbserver_init, vgdb 51 can contact the gdbserver embedded in valgrind. 52 The rest of the low level gdbserver interface can only 53 be called */ 54 extern void gdbserver_init (void); 55 56 extern void server_main (void); 57 58 /* To be called to indicate that gdbserver usage is finished. 59 Resources (e.g. FIFOs) will be destroyed. */ 60 extern void gdbserver_terminate (void); 61 62 63 /* Output string s to the gdb debugging this process or to vgdb. 64 Do not call this directly. Rather use VG_(gdb_printf) 65 to output something to gdb, use normal valgrind messaging 66 (e.g. VG_(umsg)) to send output that can either go 67 to gdb or to log. */ 68 extern void monitor_output (char *s); 69 70 /* returns 0 if there is no connection or no event on the connection 71 with gdb. 72 returns 1 if there are some data which has been received from gdb 73 and that must (still) be handled. 74 returns 2 if remote_desc_activity detected the connection has been 75 lost and should be reopened. 76 msg is used for debug logging.*/ 77 extern int remote_desc_activity(const char *msg); 78 79 /* output some status of gdbserver communication */ 80 extern void remote_utils_output_status(void); 81 82 /* True if there is a connection with gdb. */ 83 extern Bool remote_connected(void); 84 85 /* Finish the connection with gdb and reset_valgrind_sink. 86 Keeps the FIFOs and shared mem so as to allow connection 87 to be reopened. */ 88 extern void remote_finish(FinishReason reason); 89 90 /* If Valgrind sink was changed by gdbserver: 91 Resets the valgrind sink to before the changes done by gdbserver, 92 and does VG_(umsg). If info != NULL, info added in VG_(usmg). */ 93 extern void reset_valgrind_sink(const char* info); 94 95 // VG_(gdb_printf) by default writes to vgdb/gdb. 96 // If there is no connection, it will rather write to the initial (log) 97 // valgrind fd using the below. 98 extern void print_to_initial_valgrind_sink (const char *msg); 99 100 /* For ARM usage. 101 Guesses if pc is a thumb pc. 102 In this case, returns pc with the thumb bit set (bit0) 103 else just returns pc. 104 105 The guess is based on the following set of check: 106 if bit0 set => thumb 107 else if bit1 set => thumb 108 else uses the debuginfo to guess. 109 110 If debug info not found for this pc, assumes arm */ 111 extern Addr thumb_pc (Addr pc); 112 113 /* when invoked by vgdb using ptrace, contains the tid chosen 114 by vgdb (if vgdb gives a tid different of 0: a 0 tid by 115 vgdb means use the running_tid if there is one running 116 or tid 1 otherwise). */ 117 extern ThreadId vgdb_interrupted_tid; 118 119 /* True if GDB is catching client syscalls. */ 120 extern Bool catching_syscalls; 121 122 /* Size of the syscalls_to_catch. Only useful if catching_syscalls True. 123 syscalls_to_catch_size 0 means all syscalls are caught. */ 124 extern Int syscalls_to_catch_size; 125 extern Int *syscalls_to_catch; 126 127 /*------------ end of interface to low level gdbserver */ 128 129 130 #define dlog(level, ...) \ 131 do { if (UNLIKELY(VG_(debugLog_getLevel)() >= level)) \ 132 VG_(debugLog) (level, "gdbsrv",__VA_ARGS__); } \ 133 while (0) 134 135 136 /* vki only defines VKI_POLLIN but even not on all OS. 137 Below is from linux bits/poll.h */ 138 #ifndef VKI_POLLIN 139 #define VKI_POLLIN 0x0001 140 #endif 141 #define VKI_POLLPRI 0x0002 142 #define VKI_POLLOUT 0x0004 143 #define VKI_POLLERR 0x0008 144 #define VKI_POLLHUP 0x0010 145 #define VKI_POLLNVAL 0x0020 146 147 /* a bunch of macros to avoid libc usage in valgrind-ified gdbserver */ 148 #define strcmp(s1,s2) VG_(strcmp) ((s1),(s2)) 149 #define strncmp(s1,s2,nmax) VG_(strncmp) ((s1),(s2),nmax) 150 #define strcat(s1,s2) VG_(strcat) ((s1),(s2)) 151 #define strcpy(s1,s2) VG_(strcpy) ((s1),(s2)) 152 #define strncpy(s1,s2,nmax) VG_(strncpy) ((s1),(s2),nmax) 153 #define strlen(s) VG_(strlen) ((s)) 154 #define strtok(p,s) VG_(strtok) ((p),(s)) 155 #define strtok_r(p,s,ss) VG_(strtok_r) ((p),(s),(ss)) 156 #define strchr(s,c) VG_(strchr) ((s),c) 157 /* strtol and strtoul supports base 16 or else assumes it is base 10 */ 158 #define strtol(s,r,b) ((b) == 16 ? \ 159 VG_(strtoll16) ((s),(r)) \ 160 : VG_(strtoll10) ((s),(r))) 161 #define strtoul(s,r,b) ((b) == 16 ? \ 162 VG_(strtoull16) ((s),(r)) \ 163 : VG_(strtoull10) ((s),(r))) 164 165 #define malloc(sz) VG_(malloc) ("gdbsrv", sz) 166 #define calloc(n,sz) VG_(calloc) ("gdbsrv", n, sz) 167 #define realloc(p,size) VG_(realloc) ("gdbsrv", p, size) 168 #define strdup(s) VG_(strdup) ("gdbsrv", (s)) 169 #define free(b) VG_(free) (b) 170 171 #ifndef ATTR_NORETURN 172 #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)) 173 #define ATTR_NORETURN __attribute__ ((noreturn)) 174 #else 175 #define ATTR_NORETURN /* nothing */ 176 #endif 177 #endif 178 179 #ifndef ATTR_FORMAT 180 #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4)) 181 #define ATTR_FORMAT(type, x, y) __attribute__ ((format(type, x, y))) 182 #else 183 #define ATTR_FORMAT(type, x, y) /* nothing */ 184 #endif 185 #endif 186 187 /* A type used for binary buffers. */ 188 typedef unsigned char gdb_byte; 189 190 typedef Addr CORE_ADDR; 191 192 /* Generic information for tracking a list of ``inferiors'' - threads, 193 processes, etc. */ 194 struct inferior_list 195 { 196 struct inferior_list_entry *head; 197 struct inferior_list_entry *tail; 198 }; 199 struct inferior_list_entry 200 { 201 unsigned long id; 202 struct inferior_list_entry *next; 203 }; 204 205 /* Opaque type for user-visible threads. */ 206 struct thread_info; 207 208 #include "regcache.h" 209 #include "gdb/signals.h" 210 211 /* signal handling with gdbserver: before delivering a signal, 212 call gdbserver_signal_encountered. This will set 213 the signal to report in the next resume reply sent to GDB. 214 A call to call_gdbserver is needed to send the resume reply to GDB. 215 After this call, gdbserver_deliver_signal indicates if the signal 216 is effectively to be delivered to the guest process. */ 217 extern void gdbserver_signal_encountered (const vki_siginfo_t *info); 218 /* between these two calls, call call_gdbserver. 219 Between these 2 calls the signal to report to GDB can be retrieved using 220 gdbserver_pending_signal_to_report. */ 221 /* If gdbserver_deliver_signal True, then gdb did not ask 222 to ignore the signal, so signal can be delivered to the guest. */ 223 extern Bool gdbserver_deliver_signal (vki_siginfo_t *info); 224 225 /* Signal info last provided with gdbserver_signal_encountered. 226 It is what is/will be reported to GDB. */ 227 extern void gdbserver_pending_signal_to_report (vki_siginfo_t /* OUT */ *info); 228 229 /* Called when a process is about to go with reason ('W' or 'X') and code. 230 This sets global variables that will be used to return the process 231 exit status to GDB in the next resume_reply. 232 Similarly to gdbserver_signal_encountered, a call to call_gdbserver 233 is needed to send the resume reply. */ 234 extern void gdbserver_process_exit_encountered (unsigned char status, Int code); 235 236 /* To optimise signal handling, gdb can instruct gdbserver to 237 not stop on some signals. In the below, a 1 indicates the gdb_nr signal 238 has to be passed directly to the guest, without asking gdb. 239 A 0 indicates gdb has to be consulted to see if signal has 240 or has not to be passed. The gdb consultation is to 241 be done using the above two functions. */ 242 extern int pass_signals[]; /* indexed by gdb signal nr */ 243 244 245 #include "target.h" 246 247 /* Target-specific functions */ 248 249 /* From inferiors.c. */ 250 251 extern struct inferior_list all_threads; 252 void add_inferior_to_list (struct inferior_list *list, 253 struct inferior_list_entry *new_inferior); 254 void for_each_inferior (struct inferior_list *list, 255 void (*action) (struct inferior_list_entry *)); 256 extern struct thread_info *current_inferior; 257 void remove_inferior (struct inferior_list *list, 258 struct inferior_list_entry *entry); 259 void remove_thread (struct thread_info *thread); 260 void add_thread (unsigned long thread_id, void *target_data, unsigned int); 261 unsigned int thread_id_to_gdb_id (unsigned long); 262 unsigned int thread_to_gdb_id (struct thread_info *); 263 unsigned long gdb_id_to_thread_id (unsigned int); 264 struct thread_info *gdb_id_to_thread (unsigned int); 265 void clear_inferiors (void); 266 struct inferior_list_entry *find_inferior (struct inferior_list *, 267 int (*func) (struct 268 inferior_list_entry *, 269 void *), 270 void *arg); 271 struct inferior_list_entry *find_inferior_id (struct inferior_list *list, 272 unsigned long id); 273 void *inferior_target_data (struct thread_info *); 274 void set_inferior_target_data (struct thread_info *, void *); 275 void *inferior_regcache_data (struct thread_info *); 276 void set_inferior_regcache_data (struct thread_info *, void *); 277 void change_inferior_id (struct inferior_list *list, 278 unsigned long new_id); 279 280 /* Public variables in server.c */ 281 282 extern unsigned long cont_thread; 283 extern unsigned long general_thread; 284 extern unsigned long step_thread; 285 extern unsigned long thread_from_wait; 286 extern unsigned long old_thread_from_wait; 287 288 extern VG_MINIMAL_JMP_BUF(toplevel); 289 290 /* From remote-utils.c */ 291 292 extern Bool noack_mode; 293 int putpkt (char *buf); 294 int putpkt_binary (char *buf, int len); 295 int getpkt (char *buf); 296 void remote_open (const HChar *name); 297 void remote_close (void); 298 299 void sync_gdb_connection (void); 300 void write_ok (char *buf); 301 void write_enn (char *buf); 302 void convert_ascii_to_int (const char *from, unsigned char *to, int n); 303 void convert_int_to_ascii (const unsigned char *from, char *to, int n); 304 void prepare_resume_reply (char *buf, char status, unsigned char sig); 305 306 void decode_address (CORE_ADDR *addrp, const char *start, int len); 307 void decode_m_packet (char *from, CORE_ADDR * mem_addr_ptr, 308 unsigned int *len_ptr); 309 void decode_M_packet (char *from, CORE_ADDR * mem_addr_ptr, 310 unsigned int *len_ptr, unsigned char *to); 311 int decode_X_packet (char *from, int packet_len, CORE_ADDR * mem_addr_ptr, 312 unsigned int *len_ptr, unsigned char *to); 313 314 int unhexify (char *bin, const char *hex, int count); 315 int hexify (char *hex, const char *bin, int count); 316 /* heximage builds an image of bin according to byte order of the architecture 317 Useful for register and int image */ 318 char* heximage (char *buf, char *bin, int count); 319 320 /* convert from CORE_ADDR to void* */ 321 void* C2v(CORE_ADDR addr); 322 323 324 int remote_escape_output (const gdb_byte *buffer, int len, 325 gdb_byte *out_buf, int *out_len, 326 int out_maxlen); 327 328 /* Functions from ``signals.c''. */ 329 enum target_signal target_signal_from_host (int hostsig); 330 int target_signal_to_host_p (enum target_signal oursig); 331 int target_signal_to_host (enum target_signal oursig); 332 const char *target_signal_to_name (enum target_signal); 333 334 /* Functions from utils.c */ 335 336 /* error is like VG_(umsg), then VG_MINIMAL_LONGJMP to gdbserver toplevel. */ 337 void error (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2); 338 /* first output a description of the error inside sr, then like VG_(umsg). */ 339 void sr_perror (SysRes sr,const char *string,...) ATTR_FORMAT (printf, 2, 3); 340 /* fatal is like VG_(umsg), then exit(1). */ 341 void fatal (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2); 342 /* warning is like VG_(umsg). */ 343 void warning (const char *string,...) ATTR_FORMAT (printf, 1, 2); 344 345 /* Functions from the register cache definition. */ 346 347 void init_registers (void); 348 349 /* Maximum number of bytes to read/write at once. The value here 350 is chosen to fill up a packet (the headers account for the 32). */ 351 #define MAXBUFBYTES(N) (((N)-32)/2) 352 353 /* PBUFSIZ : Buffers size for transferring memory, registers, etc. 354 Must be big enough to hold all the registers, at least. 355 Must be at least big as 2*DATASIZ + 5: 356 1 : packet begin ($ or %) 357 + 2*DATASIZ : encoded string 358 + 1 : packet end (#) 359 + 2 : packet checksum 360 + 1 : \0 361 362 Max value gdb likes is 16384. 363 364 Note that what is sent/received to/from gdb does 365 not have a trailing null byte. We are adding 1 here to allow 366 null terminating the strings e.g. for printf. 367 368 => packet Packet OVERHead SIZe is 5:*/ 369 370 /* keep PBUFSIZ value in sync with vgdb.c */ 371 #define PBUFSIZ 16384 372 #define POVERHSIZ 5 373 374 /* Max size of a string encoded in a packet. Hex Encoding can 375 multiply the size by 2 (trailing null byte not sent). */ 376 #define DATASIZ ((PBUFSIZ-POVERHSIZ)/2) 377 378 /* Version information, from version.c. */ 379 extern const char version[]; 380 381 #endif /* SERVER_H */ 382
