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