• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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