Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / common / agent.c
1 /* Shared utility routines for GDB to interact with agent.
2
3    Copyright (C) 2009-2013 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #ifdef GDBSERVER
21 #include "server.h"
22 #else
23 #include "defs.h"
24 #include "target.h"
25 #include "inferior.h" /* for non_stop */
26 #endif
27
28 #include <string.h>
29 #include <unistd.h>
30 #include "agent.h"
31
32 int debug_agent = 0;
33
34 #ifdef GDBSERVER
35 #define DEBUG_AGENT(fmt, args...)       \
36   if (debug_agent)                      \
37     fprintf (stderr, fmt, ##args);
38 #else
39 #define DEBUG_AGENT(fmt, args...)       \
40   if (debug_agent)                      \
41     fprintf_unfiltered (gdb_stdlog, fmt, ##args);
42 #endif
43
44 /* Global flag to determine using agent or not.  */
45 int use_agent = 0;
46
47 /* Addresses of in-process agent's symbols both GDB and GDBserver cares
48    about.  */
49
50 struct ipa_sym_addresses
51 {
52   CORE_ADDR addr_helper_thread_id;
53   CORE_ADDR addr_cmd_buf;
54   CORE_ADDR addr_capability;
55 };
56
57 /* Cache of the helper thread id.  FIXME: this global should be made
58    per-process.  */
59 static unsigned int helper_thread_id = 0;
60
61 static struct
62 {
63   const char *name;
64   int offset;
65   int required;
66 } symbol_list[] = {
67   IPA_SYM(helper_thread_id),
68   IPA_SYM(cmd_buf),
69   IPA_SYM(capability),
70 };
71
72 static struct ipa_sym_addresses ipa_sym_addrs;
73
74 static int all_agent_symbols_looked_up = 0;
75
76 int
77 agent_loaded_p (void)
78 {
79   return all_agent_symbols_looked_up;
80 }
81
82 /* Look up all symbols needed by agent.  Return 0 if all the symbols are
83    found, return non-zero otherwise.  */
84
85 int
86 agent_look_up_symbols (void *arg)
87 {
88   int i;
89
90   all_agent_symbols_looked_up = 0;
91
92   for (i = 0; i < sizeof (symbol_list) / sizeof (symbol_list[0]); i++)
93     {
94       CORE_ADDR *addrp =
95         (CORE_ADDR *) ((char *) &ipa_sym_addrs + symbol_list[i].offset);
96 #ifdef GDBSERVER
97
98       if (look_up_one_symbol (symbol_list[i].name, addrp, 1) == 0)
99 #else
100       struct minimal_symbol *sym =
101         lookup_minimal_symbol (symbol_list[i].name, NULL,
102                                (struct objfile *) arg);
103
104       if (sym != NULL)
105         *addrp = SYMBOL_VALUE_ADDRESS (sym);
106       else
107 #endif
108         {
109           DEBUG_AGENT ("symbol `%s' not found\n", symbol_list[i].name);
110           return -1;
111         }
112     }
113
114   all_agent_symbols_looked_up = 1;
115   return 0;
116 }
117
118 static unsigned int
119 agent_get_helper_thread_id (void)
120 {
121   if  (helper_thread_id == 0)
122     {
123 #ifdef GDBSERVER
124       if (read_inferior_memory (ipa_sym_addrs.addr_helper_thread_id,
125                                 (unsigned char *) &helper_thread_id,
126                                 sizeof helper_thread_id))
127 #else
128       enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
129       gdb_byte buf[4];
130
131       if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id,
132                               buf, sizeof buf) == 0)
133         helper_thread_id = extract_unsigned_integer (buf, sizeof buf,
134                                                      byte_order);
135       else
136 #endif
137         {
138           warning (_("Error reading helper thread's id in lib"));
139         }
140     }
141
142   return helper_thread_id;
143 }
144
145 #ifdef HAVE_SYS_UN_H
146 #include <sys/socket.h>
147 #include <sys/un.h>
148 #define SOCK_DIR P_tmpdir
149
150 #ifndef UNIX_PATH_MAX
151 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
152 #endif
153
154 #endif
155
156 /* Connects to synchronization socket.  PID is the pid of inferior, which is
157    used to set up the connection socket.  */
158
159 static int
160 gdb_connect_sync_socket (int pid)
161 {
162 #ifdef HAVE_SYS_UN_H
163   struct sockaddr_un addr;
164   int res, fd;
165   char path[UNIX_PATH_MAX];
166
167   res = xsnprintf (path, UNIX_PATH_MAX, "%s/gdb_ust%d", P_tmpdir, pid);
168   if (res >= UNIX_PATH_MAX)
169     return -1;
170
171   res = fd = socket (PF_UNIX, SOCK_STREAM, 0);
172   if (res == -1)
173     {
174       warning (_("error opening sync socket: %s"), strerror (errno));
175       return -1;
176     }
177
178   addr.sun_family = AF_UNIX;
179
180   res = xsnprintf (addr.sun_path, UNIX_PATH_MAX, "%s", path);
181   if (res >= UNIX_PATH_MAX)
182     {
183       warning (_("string overflow allocating socket name"));
184       close (fd);
185       return -1;
186     }
187
188   res = connect (fd, (struct sockaddr *) &addr, sizeof (addr));
189   if (res == -1)
190     {
191       warning (_("error connecting sync socket (%s): %s. "
192                  "Make sure the directory exists and that it is writable."),
193                  path, strerror (errno));
194       close (fd);
195       return -1;
196     }
197
198   return fd;
199 #else
200   return -1;
201 #endif
202 }
203
204 /* Execute an agent command in the inferior.  PID is the value of pid of the
205    inferior.  CMD is the buffer for command.  GDB or GDBserver will store the
206    command into it and fetch the return result from CMD.  The interaction
207    between GDB/GDBserver and the agent is synchronized by a synchronization
208    socket.  Return zero if success, otherwise return non-zero.  */
209
210 int
211 agent_run_command (int pid, const char *cmd, int len)
212 {
213   int fd;
214   int tid = agent_get_helper_thread_id ();
215   ptid_t ptid = ptid_build (pid, tid, 0);
216
217 #ifdef GDBSERVER
218   int ret = write_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
219                                    (const unsigned char *) cmd, len);
220 #else
221   int ret = target_write_memory (ipa_sym_addrs.addr_cmd_buf, cmd, len);
222 #endif
223
224   if (ret != 0)
225     {
226       warning (_("unable to write"));
227       return -1;
228     }
229
230   DEBUG_AGENT ("agent: resumed helper thread\n");
231
232   /* Resume helper thread.  */
233 #ifdef GDBSERVER
234 {
235   struct thread_resume resume_info;
236
237   resume_info.thread = ptid;
238   resume_info.kind = resume_continue;
239   resume_info.sig = GDB_SIGNAL_0;
240   (*the_target->resume) (&resume_info, 1);
241 }
242 #else
243  target_resume (ptid, 0, GDB_SIGNAL_0);
244 #endif
245
246   fd = gdb_connect_sync_socket (pid);
247   if (fd >= 0)
248     {
249       char buf[1] = "";
250       int ret;
251
252       DEBUG_AGENT ("agent: signalling helper thread\n");
253
254       do
255         {
256           ret = write (fd, buf, 1);
257         } while (ret == -1 && errno == EINTR);
258
259         DEBUG_AGENT ("agent: waiting for helper thread's response\n");
260
261       do
262         {
263           ret = read (fd, buf, 1);
264         } while (ret == -1 && errno == EINTR);
265
266       close (fd);
267
268       DEBUG_AGENT ("agent: helper thread's response received\n");
269     }
270   else
271     return -1;
272
273   /* Need to read response with the inferior stopped.  */
274   if (!ptid_equal (ptid, null_ptid))
275     {
276       struct target_waitstatus status;
277       int was_non_stop = non_stop;
278       /* Stop thread PTID.  */
279       DEBUG_AGENT ("agent: stop helper thread\n");
280 #ifdef GDBSERVER
281       {
282         struct thread_resume resume_info;
283
284         resume_info.thread = ptid;
285         resume_info.kind = resume_stop;
286         resume_info.sig = GDB_SIGNAL_0;
287         (*the_target->resume) (&resume_info, 1);
288       }
289
290       non_stop = 1;
291       mywait (ptid, &status, 0, 0);
292 #else
293       non_stop = 1;
294       target_stop (ptid);
295
296       memset (&status, 0, sizeof (status));
297       target_wait (ptid, &status, 0);
298 #endif
299       non_stop = was_non_stop;
300     }
301
302   if (fd >= 0)
303     {
304 #ifdef GDBSERVER
305       if (read_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
306                                 (unsigned char *) cmd, IPA_CMD_BUF_SIZE))
307 #else
308       if (target_read_memory (ipa_sym_addrs.addr_cmd_buf, (gdb_byte *) cmd,
309                               IPA_CMD_BUF_SIZE))
310 #endif
311         {
312           warning (_("Error reading command response"));
313           return -1;
314         }
315     }
316
317   return 0;
318 }
319
320 /* Each bit of it stands for a capability of agent.  */
321 static unsigned int agent_capability = 0;
322
323 /* Return true if agent has capability AGENT_CAP, otherwise return false.  */
324
325 int
326 agent_capability_check (enum agent_capa agent_capa)
327 {
328   if (agent_capability == 0)
329     {
330 #ifdef GDBSERVER
331       if (read_inferior_memory (ipa_sym_addrs.addr_capability,
332                                 (unsigned char *) &agent_capability,
333                                 sizeof agent_capability))
334 #else
335       enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
336       gdb_byte buf[4];
337
338       if (target_read_memory (ipa_sym_addrs.addr_capability,
339                               buf, sizeof buf) == 0)
340         agent_capability = extract_unsigned_integer (buf, sizeof buf,
341                                                      byte_order);
342       else
343 #endif
344         warning (_("Error reading capability of agent"));
345     }
346   return agent_capability & agent_capa;
347 }
348
349 /* Invalidate the cache of agent capability, so we'll read it from inferior
350    again.  Call it when launches a new program or reconnect to remote stub.  */
351
352 void
353 agent_capability_invalidate (void)
354 {
355   agent_capability = 0;
356 }