[deliverable/binutils-gdb.git] / gdb / common / agent.c

/* Shared utility routines for GDB to interact with agent.

   Copyright (C) 2009-2012 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifdef GDBSERVER
#include "server.h"
#else
#include "defs.h"
#include "target.h"
#include "inferior.h" /* for non_stop */
#endif

#include <string.h>
#include <unistd.h>
#include "agent.h"

int debug_agent = 0;

#ifdef GDBSERVER
#define DEBUG_AGENT(fmt, args...)	\
  if (debug_agent)			\
    fprintf (stderr, fmt, ##args);
#else
#define DEBUG_AGENT(fmt, args...)	\
  if (debug_agent)			\
    fprintf_unfiltered (gdb_stdlog, fmt, ##args);
#endif

/* Global flag to determine using agent or not.  */
int use_agent = 0;

/* Addresses of in-process agent's symbols both GDB and GDBserver cares
   about.  */

struct ipa_sym_addresses
{
  CORE_ADDR addr_helper_thread_id;
  CORE_ADDR addr_cmd_buf;
  CORE_ADDR addr_capability;
};

/* Cache of the helper thread id.  FIXME: this global should be made
   per-process.  */
static unsigned int helper_thread_id = 0;

static struct
{
  const char *name;
  int offset;
  int required;
} symbol_list[] = {
  IPA_SYM(helper_thread_id),
  IPA_SYM(cmd_buf),
  IPA_SYM(capability),
};

static struct ipa_sym_addresses ipa_sym_addrs;

static int all_agent_symbols_looked_up = 0;

int
agent_loaded_p (void)
{
  return all_agent_symbols_looked_up;
}

/* Look up all symbols needed by agent.  Return 0 if all the symbols are
   found, return non-zero otherwise.  */

int
agent_look_up_symbols (void)
{
  int i;

  all_agent_symbols_looked_up = 0;

  for (i = 0; i < sizeof (symbol_list) / sizeof (symbol_list[0]); i++)
    {
      CORE_ADDR *addrp =
	(CORE_ADDR *) ((char *) &ipa_sym_addrs + symbol_list[i].offset);
#ifdef GDBSERVER

      if (look_up_one_symbol (symbol_list[i].name, addrp, 1) == 0)
#else
      struct minimal_symbol *sym = lookup_minimal_symbol (symbol_list[i].name,
							  NULL, NULL);

      if (sym != NULL)
	*addrp = SYMBOL_VALUE_ADDRESS (sym);
      else
#endif
	{
	  DEBUG_AGENT ("symbol `%s' not found\n", symbol_list[i].name);
	  return -1;
	}
    }

  all_agent_symbols_looked_up = 1;
  return 0;
}

static unsigned int
agent_get_helper_thread_id (void)
{
  if  (helper_thread_id == 0)
    {
#ifdef GDBSERVER
      if (read_inferior_memory (ipa_sym_addrs.addr_helper_thread_id,
				(unsigned char *) &helper_thread_id,
				sizeof helper_thread_id))
#else
      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
      gdb_byte buf[4];

      if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id,
			      buf, sizeof buf) == 0)
	helper_thread_id = extract_unsigned_integer (buf, sizeof buf,
						     byte_order);
      else
#endif
	{
	  warning ("Error reading helper thread's id in lib");
	}
    }

  return helper_thread_id;
}

#ifdef HAVE_SYS_UN_H
#include <sys/socket.h>
#include <sys/un.h>
#define SOCK_DIR P_tmpdir

#ifndef UNIX_PATH_MAX
#define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
#endif

#endif

/* Connects to synchronization socket.  PID is the pid of inferior, which is
   used to set up the connection socket.  */

static int
gdb_connect_sync_socket (int pid)
{
#ifdef HAVE_SYS_UN_H
  struct sockaddr_un addr;
  int res, fd;
  char path[UNIX_PATH_MAX];

  res = xsnprintf (path, UNIX_PATH_MAX, "%s/gdb_ust%d", P_tmpdir, pid);
  if (res >= UNIX_PATH_MAX)
    return -1;

  res = fd = socket (PF_UNIX, SOCK_STREAM, 0);
  if (res == -1)
    {
      warning ("error opening sync socket: %s\n", strerror (errno));
      return -1;
    }

  addr.sun_family = AF_UNIX;

  res = xsnprintf (addr.sun_path, UNIX_PATH_MAX, "%s", path);
  if (res >= UNIX_PATH_MAX)
    {
      warning ("string overflow allocating socket name\n");
      close (fd);
      return -1;
    }

  res = connect (fd, (struct sockaddr *) &addr, sizeof (addr));
  if (res == -1)
    {
      warning ("error connecting sync socket (%s): %s. "
	       "Make sure the directory exists and that it is writable.",
	       path, strerror (errno));
      close (fd);
      return -1;
    }

  return fd;
#else
  return -1;
#endif
}

/* Execute an agent command in the inferior.  PID is the value of pid of the
   inferior.  CMD is the buffer for command.  GDB or GDBserver will store the
   command into it and fetch the return result from CMD.  The interaction
   between GDB/GDBserver and the agent is synchronized by a synchronization
   socket.  Return zero if success, otherwise return non-zero.  */

int
agent_run_command (int pid, const char *cmd)
{
  int fd;
  int tid = agent_get_helper_thread_id ();
  ptid_t ptid = ptid_build (pid, tid, 0);
  int len = strlen (cmd) + 1;

#ifdef GDBSERVER
  int ret = write_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
				   (const unsigned char *) cmd, len);
#else
  int ret = target_write_memory (ipa_sym_addrs.addr_cmd_buf, cmd, len);
#endif

  if (ret != 0)
    {
      warning ("unable to write");
      return -1;
    }

  DEBUG_AGENT ("agent: resumed helper thread\n");

  /* Resume helper thread.  */
#ifdef GDBSERVER
{
  struct thread_resume resume_info;

  resume_info.thread = ptid;
  resume_info.kind = resume_continue;
  resume_info.sig = TARGET_SIGNAL_0;
  (*the_target->resume) (&resume_info, 1);
}
#else
 target_resume (ptid, 0, TARGET_SIGNAL_0);
#endif

  fd = gdb_connect_sync_socket (pid);
  if (fd >= 0)
    {
      char buf[1] = "";
      int ret;

      DEBUG_AGENT ("agent: signalling helper thread\n");

      do
	{
	  ret = write (fd, buf, 1);
	} while (ret == -1 && errno == EINTR);

	DEBUG_AGENT ("agent: waiting for helper thread's response\n");

      do
	{
	  ret = read (fd, buf, 1);
	} while (ret == -1 && errno == EINTR);

      close (fd);

      DEBUG_AGENT ("agent: helper thread's response received\n");
    }
  else
    return -1;

  /* Need to read response with the inferior stopped.  */
  if (!ptid_equal (ptid, null_ptid))
    {
      struct target_waitstatus status;
      int was_non_stop = non_stop;
      /* Stop thread PTID.  */
      DEBUG_AGENT ("agent: stop helper thread\n");
#ifdef GDBSERVER
      {
	struct thread_resume resume_info;

	resume_info.thread = ptid;
	resume_info.kind = resume_stop;
	resume_info.sig = TARGET_SIGNAL_0;
	(*the_target->resume) (&resume_info, 1);
      }

      non_stop = 1;
      mywait (ptid, &status, 0, 0);
#else
      non_stop = 1;
      target_stop (ptid);

      memset (&status, 0, sizeof (status));
      target_wait (ptid, &status, 0);
#endif
      non_stop = was_non_stop;
    }

  if (fd >= 0)
    {
#ifdef GDBSERVER
      if (read_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
				(unsigned char *) cmd, IPA_CMD_BUF_SIZE))
#else
      if (target_read_memory (ipa_sym_addrs.addr_cmd_buf, (gdb_byte *) cmd,
			      IPA_CMD_BUF_SIZE))
#endif
	{
	  warning ("Error reading command response");
	  return -1;
	}
    }

  return 0;
}

/* Each bit of it stands for a capability of agent.  */
static unsigned int agent_capability = 0;

/* Return true if agent has capability AGENT_CAP, otherwise return false.  */

int
agent_capability_check (enum agent_capa agent_capa)
{
  if (agent_capability == 0)
    {
#ifdef GDBSERVER
      if (read_inferior_memory (ipa_sym_addrs.addr_capability,
				(unsigned char *) &agent_capability,
				sizeof agent_capability))
#else
      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
      gdb_byte buf[4];

      if (target_read_memory (ipa_sym_addrs.addr_capability,
			      buf, sizeof buf) == 0)
	agent_capability = extract_unsigned_integer (buf, sizeof buf,
						     byte_order);
      else
#endif
	warning ("Error reading capability of agent");
    }
  return agent_capability & agent_capa;
}

/* Invalidate the cache of agent capability, so we'll read it from inferior
   again.  Call it when launches a new program or reconnect to remote stub.  */

void
agent_capability_invalidate (void)
{
  agent_capability = 0;
}
Commit	Line	Data
2fa291ac YQ	1	/* Shared utility routines for GDB to interact with agent.
	2
	3	Copyright (C) 2009-2012 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
d1feda86 YQ	44	/* Global flag to determine using agent or not. */
	45	int use_agent = 0;
	46
2fa291ac YQ	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;
8ffcbaaf	54	CORE_ADDR addr_capability;
2fa291ac YQ	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),
8ffcbaaf	69	IPA_SYM(capability),
2fa291ac YQ	70	};
	71
	72	static struct ipa_sym_addresses ipa_sym_addrs;
	73
58b4daa5 YQ	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
2fa291ac YQ	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)
	87	{
	88	int i;
	89
58b4daa5 YQ	90	all_agent_symbols_looked_up = 0;
58b4daa5 YQ	91
2fa291ac YQ	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 = lookup_minimal_symbol (symbol_list[i].name,
	101	NULL, NULL);
	102
	103	if (sym != NULL)
	104	*addrp = SYMBOL_VALUE_ADDRESS (sym);
	105	else
	106	#endif
	107	{
	108	DEBUG_AGENT ("symbol `%s' not found\n", symbol_list[i].name);
	109	return -1;
	110	}
	111	}
	112
58b4daa5	113	all_agent_symbols_looked_up = 1;
2fa291ac YQ	114	return 0;
	115	}
	116
	117	static unsigned int
	118	agent_get_helper_thread_id (void)
	119	{
	120	if (helper_thread_id == 0)
	121	{
	122	#ifdef GDBSERVER
	123	if (read_inferior_memory (ipa_sym_addrs.addr_helper_thread_id,
	124	(unsigned char *) &helper_thread_id,
	125	sizeof helper_thread_id))
	126	#else
	127	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
	128	gdb_byte buf[4];
	129
	130	if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id,
	131	buf, sizeof buf) == 0)
	132	helper_thread_id = extract_unsigned_integer (buf, sizeof buf,
	133	byte_order);
	134	else
	135	#endif
	136	{
	137	warning ("Error reading helper thread's id in lib");
	138	}
	139	}
	140
	141	return helper_thread_id;
	142	}
	143
	144	#ifdef HAVE_SYS_UN_H
	145	#include <sys/socket.h>
	146	#include <sys/un.h>
	147	#define SOCK_DIR P_tmpdir
	148
	149	#ifndef UNIX_PATH_MAX
	150	#define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
	151	#endif
	152
	153	#endif
	154
	155	/* Connects to synchronization socket. PID is the pid of inferior, which is
	156	used to set up the connection socket. */
	157
	158	static int
	159	gdb_connect_sync_socket (int pid)
	160	{
	161	#ifdef HAVE_SYS_UN_H
	162	struct sockaddr_un addr;
	163	int res, fd;
	164	char path[UNIX_PATH_MAX];
	165
	166	res = xsnprintf (path, UNIX_PATH_MAX, "%s/gdb_ust%d", P_tmpdir, pid);
	167	if (res >= UNIX_PATH_MAX)
	168	return -1;
	169
	170	res = fd = socket (PF_UNIX, SOCK_STREAM, 0);
	171	if (res == -1)
	172	{
	173	warning ("error opening sync socket: %s\n", strerror (errno));
	174	return -1;
	175	}
	176
	177	addr.sun_family = AF_UNIX;
178
179	res = xsnprintf (addr.sun_path, UNIX_PATH_MAX, "%s", path);
180	if (res >= UNIX_PATH_MAX)
181	{
182	warning ("string overflow allocating socket name\n");
183	close (fd);
184	return -1;
185	}
186
187	res = connect (fd, (struct sockaddr *) &addr, sizeof (addr));
188	if (res == -1)
189	{
190	warning ("error connecting sync socket (%s): %s. "
191	"Make sure the directory exists and that it is writable.",
192	path, strerror (errno));
193	close (fd);
194	return -1;
195	}
196
197	return fd;
198	#else
199	return -1;
200	#endif
201	}
202
203	/* Execute an agent command in the inferior. PID is the value of pid of the
204	inferior. CMD is the buffer for command. GDB or GDBserver will store the
205	command into it and fetch the return result from CMD. The interaction
206	between GDB/GDBserver and the agent is synchronized by a synchronization
207	socket. Return zero if success, otherwise return non-zero. */
208
209	int
210	agent_run_command (int pid, const char *cmd)
211	{
212	int fd;
213	int tid = agent_get_helper_thread_id ();
214	ptid_t ptid = ptid_build (pid, tid, 0);
215	int len = strlen (cmd) + 1;
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 = TARGET_SIGNAL_0;
240	(*the_target->resume) (&resume_info, 1);
241	}
242	#else
243	target_resume (ptid, 0, TARGET_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 = TARGET_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	}
8ffcbaaf YQ	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	}