/* Tracepoint code for remote server for GDB.
- Copyright (C) 2009-2017 Free Software Foundation, Inc.
+ Copyright (C) 2009-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "server.h"
#include "tracepoint.h"
#include "gdbthread.h"
-#include "agent.h"
-#include "rsp-low.h"
+#include "gdbsupport/rsp-low.h"
#include <ctype.h>
#include <fcntl.h>
#include "ax.h"
#include "tdesc.h"
+#define IPA_SYM_STRUCT_NAME ipa_sym_addresses
+#include "gdbsupport/agent.h"
+
#define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
/* This file is built for both GDBserver, and the in-process
write_inferior_data_pointer (CORE_ADDR symaddr, CORE_ADDR val)
{
void *pval = (void *) (uintptr_t) val;
- return write_inferior_memory (symaddr,
+ return target_write_memory (symaddr,
(unsigned char *) &pval, sizeof (pval));
}
static int
write_inferior_integer (CORE_ADDR symaddr, int val)
{
- return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
+ return target_write_memory (symaddr, (unsigned char *) &val, sizeof (val));
}
static int
write_inferior_int8 (CORE_ADDR symaddr, int8_t val)
{
- return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
+ return target_write_memory (symaddr, (unsigned char *) &val, sizeof (val));
}
static int
write_inferior_uinteger (CORE_ADDR symaddr, unsigned int val)
{
- return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
+ return target_write_memory (symaddr, (unsigned char *) &val, sizeof (val));
}
static CORE_ADDR target_malloc (ULONGEST size);
{
CORE_ADDR ipa_action = target_malloc (sizeof (struct collect_memory_action));
- write_inferior_memory (ipa_action, (unsigned char *) action,
+ target_write_memory (ipa_action, (unsigned char *) action,
sizeof (struct collect_memory_action));
return ipa_action;
{
CORE_ADDR ipa_action = target_malloc (sizeof (struct collect_registers_action));
- write_inferior_memory (ipa_action, (unsigned char *) action,
+ target_write_memory (ipa_action, (unsigned char *) action,
sizeof (struct collect_registers_action));
return ipa_action;
CORE_ADDR ipa_action = target_malloc (sizeof (struct eval_expr_action));
CORE_ADDR expr;
- write_inferior_memory (ipa_action, (unsigned char *) action,
+ target_write_memory (ipa_action, (unsigned char *) action,
sizeof (struct eval_expr_action));
expr = download_agent_expr (((struct eval_expr_action *) action)->expr);
write_inferior_data_pointer (ipa_action
CORE_ADDR ipa_action
= target_malloc (sizeof (struct collect_static_trace_data_action));
- write_inferior_memory (ipa_action, (unsigned char *) action,
+ target_write_memory (ipa_action, (unsigned char *) action,
sizeof (struct collect_static_trace_data_action));
return ipa_action;
fields (and no data) marks the end of trace data. */
#define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
-/* The traceframe to be used as the source of data to send back to
- GDB. A value of -1 means to get data from the live program. */
-
-int current_traceframe = -1;
-
/* This flag is true if the trace buffer is circular, meaning that
when it fills, the oldest trace frames are discarded in order to
make room. */
/* Control structure holding the read/write/etc. pointers into the
trace buffer. We need more than one of these to implement a
- transaction-like mechanism to garantees that both GDBserver and the
+ transaction-like mechanism to guarantees that both GDBserver and the
in-process agent can try to change the trace buffer
simultaneously. */
ipa_trace_buffer_ctrl.wrap = ipa_trace_buffer_hi;
/* A traceframe with zeroed fields marks the end of trace data. */
- write_inferior_memory (ipa_sym_addrs.addr_trace_buffer_ctrl,
+ target_write_memory (ipa_sym_addrs.addr_trace_buffer_ctrl,
(unsigned char *) &ipa_trace_buffer_ctrl,
sizeof (ipa_trace_buffer_ctrl));
write_inferior_uinteger (ipa_sym_addrs.addr_trace_buffer_ctrl_curr, 0);
/* A traceframe with zeroed fields marks the end of trace data. */
- write_inferior_memory (ipa_trace_buffer_lo,
+ target_write_memory (ipa_trace_buffer_lo,
(unsigned char *) &ipa_traceframe,
sizeof (ipa_traceframe));
/* Append another action to perform when the tracepoint triggers. */
static void
-add_tracepoint_action (struct tracepoint *tpoint, char *packet)
+add_tracepoint_action (struct tracepoint *tpoint, const char *packet)
{
- char *act;
+ const char *act;
if (*packet == 'S')
{
while (*act)
{
- char *act_start = act;
+ const char *act_start = act;
struct tracepoint_action *action = NULL;
switch (*act)
find_next_traceframe_in_range (CORE_ADDR lo, CORE_ADDR hi, int inside_p,
int *tfnump)
{
+ client_state &cs = get_client_state ();
struct traceframe *tframe;
CORE_ADDR tfaddr;
- *tfnump = current_traceframe + 1;
+ *tfnump = cs.current_traceframe + 1;
tframe = find_traceframe (*tfnump);
/* The search is not supposed to wrap around. */
if (!tframe)
static struct traceframe *
find_next_traceframe_by_tracepoint (int num, int *tfnump)
{
+ client_state &cs = get_client_state ();
struct traceframe *tframe;
- *tfnump = current_traceframe + 1;
+ *tfnump = cs.current_traceframe + 1;
tframe = find_traceframe (*tfnump);
/* The search is not supposed to wrap around. */
if (!tframe)
static void
cmd_qtinit (char *packet)
{
+ client_state &cs = get_client_state ();
struct trace_state_variable *tsv, *prev, *next;
/* Can't do this command without a pid attached. */
}
/* Make sure we don't try to read from a trace frame. */
- current_traceframe = -1;
+ cs.current_traceframe = -1;
stop_tracing ();
ULONGEST addr;
ULONGEST count;
struct tracepoint *tpoint;
- char *actparm;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("QTDP:");
}
else if (*packet == 'X')
{
- actparm = (char *) packet;
- tpoint->cond = gdb_parse_agent_expr (&actparm);
- packet = actparm;
+ tpoint->cond = gdb_parse_agent_expr (&packet);
}
else if (*packet == '-')
break;
{
ULONGEST num, addr, start, slen;
struct tracepoint *tpoint;
- char *packet = own_buf;
- char *saved, *srctype, *src;
+ const char *packet = own_buf;
+ const char *saved;
+ char *srctype, *src;
size_t nbytes;
struct source_string *last, *newlast;
char *varname;
size_t nbytes;
struct trace_state_variable *tsv;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("QTDV:");
static void
cmd_qtenable_disable (char *own_buf, int enable)
{
- char *packet = own_buf;
+ const char *packet = own_buf;
ULONGEST num, addr;
struct tracepoint *tp;
static void
cmd_qtv (char *own_buf)
{
+ client_state &cs = get_client_state ();
ULONGEST num;
LONGEST val = 0;
int err;
packet += strlen ("qTV:");
unpack_varlen_hex (packet, &num);
- if (current_traceframe >= 0)
+ if (cs.current_traceframe >= 0)
{
err = traceframe_read_tsv ((int) num, &val);
if (err)
{
ULONGEST start, end;
struct readonly_region *roreg;
- char *packet = own_buf;
+ const char *packet = own_buf;
trace_debug ("Want to mark readonly regions");
static void
cmd_qtframe (char *own_buf)
{
+ client_state &cs = get_client_state ();
ULONGEST frame, pc, lo, hi, num;
int tfnum, tpnum;
struct traceframe *tframe;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("QTFrame:");
if (tfnum == -1)
{
trace_debug ("Want to stop looking at traceframes");
- current_traceframe = -1;
+ cs.current_traceframe = -1;
write_ok (own_buf);
return;
}
if (tframe)
{
- current_traceframe = tfnum;
+ cs.current_traceframe = tfnum;
sprintf (own_buf, "F%xT%x", tfnum, tframe->tpnum);
}
else
{
ULONGEST num, addr;
struct tracepoint *tpoint;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("qTP:");
{
ULONGEST offset, num, tot;
unsigned char *tbp;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("qTBuffer:");
wstep_link = &tinfo->while_stepping;
trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
- target_pid_to_str (tinfo->entry.id),
+ target_pid_to_str (tinfo->id),
wstep->tp_number, paddress (wstep->tp_address));
ctx.base.type = trap_tracepoint;
{
trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
wstep->tp_number, paddress (wstep->tp_address),
- target_pid_to_str (tinfo->entry.id));
+ target_pid_to_str (tinfo->id));
/* Unlink. */
*wstep_link = wstep->next;
{
/* The requested numbers of steps have occurred. */
trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
- target_pid_to_str (tinfo->entry.id),
+ target_pid_to_str (tinfo->id),
wstep->tp_number, paddress (wstep->tp_address));
/* Unlink the wstep. */
&& tpoint->type != static_tracepoint)
{
trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
- target_pid_to_str (tinfo->entry.id),
+ target_pid_to_str (tinfo->id),
tpoint->number, paddress (tpoint->address));
/* Test the condition if present, and collect if true. */
return NULL;
}
-/* Look for the block of type TYPE_WANTED in the trameframe starting
+/* Look for the block of type TYPE_WANTED in the traceframe starting
at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
number. */
static int
traceframe_read_tsv (int tsvnum, LONGEST *val)
{
+ client_state &cs = get_client_state ();
int tfnum;
struct traceframe *tframe;
unsigned char *database, *dataptr;
trace_debug ("traceframe_read_tsv");
- tfnum = current_traceframe;
+ tfnum = cs.current_traceframe;
if (tfnum < 0)
{
CORE_ADDR expr_bytes;
expr_addr = target_malloc (sizeof (*expr));
- write_inferior_memory (expr_addr, (unsigned char *) expr, sizeof (*expr));
+ target_write_memory (expr_addr, (unsigned char *) expr, sizeof (*expr));
expr_bytes = target_malloc (expr->length);
write_inferior_data_pointer (expr_addr + offsetof (struct agent_expr, bytes),
expr_bytes);
- write_inferior_memory (expr_bytes, expr->bytes, expr->length);
+ target_write_memory (expr_bytes, expr->bytes, expr->length);
return expr_addr;
}
tracepoints before clearing our own copy. */
target_tracepoint.hit_count = 0;
- write_inferior_memory (tpptr, (unsigned char *) &target_tracepoint,
+ target_write_memory (tpptr, (unsigned char *) &target_tracepoint,
sizeof (target_tracepoint));
if (tpoint->cond)
Assume no next, fixup when needed. */
target_tsv.next = NULL;
- write_inferior_memory (ptr, (unsigned char *) &target_tsv,
+ target_write_memory (ptr, (unsigned char *) &target_tsv,
sizeof (target_tsv));
if (tsv->name != NULL)
{
size_t size = strlen (tsv->name) + 1;
CORE_ADDR name_addr = target_malloc (size);
- write_inferior_memory (name_addr,
+ target_write_memory (name_addr,
(unsigned char *) tsv->name, size);
write_inferior_data_pointer (ptr
+ offsetof (struct trace_state_variable,
into GDBserver's trace buffer. This always uploads either all or
no trace frames. This is the counter part of
`trace_alloc_trace_buffer'. See its description of the atomic
- synching mechanism. */
+ syncing mechanism. */
static void
upload_fast_traceframes (void)
(int) (ipa_trace_buffer_hi - ipa_trace_buffer_lo));
}
- if (write_inferior_memory (ipa_trace_buffer_ctrl_addr,
+ if (target_write_memory (ipa_trace_buffer_ctrl_addr,
(unsigned char *) &ipa_trace_buffer_ctrl,
sizeof (struct ipa_trace_buffer_control)))
return;
run_inferior_command (char *cmd, int len)
{
int err = -1;
- int pid = ptid_get_pid (current_ptid);
+ int pid = current_ptid.pid ();
trace_debug ("run_inferior_command: running: %s", cmd);
result = fd = socket (PF_UNIX, SOCK_STREAM, 0);
if (result == -1)
{
- warning ("socket creation failed: %s", strerror (errno));
+ warning ("socket creation failed: %s", safe_strerror (errno));
return -1;
}
result = unlink (name);
if (result == -1)
{
- warning ("unlink failed: %s", strerror (errno));
+ warning ("unlink failed: %s", safe_strerror (errno));
close (fd);
return -1;
}
result = bind (fd, (struct sockaddr *) &addr, sizeof (addr));
if (result == -1)
{
- warning ("bind failed: %s", strerror (errno));
+ warning ("bind failed: %s", safe_strerror (errno));
close (fd);
return -1;
}
result = listen (fd, 1);
if (result == -1)
{
- warning ("listen: %s", strerror (errno));
+ warning ("listen: %s", safe_strerror (errno));
close (fd);
return -1;
}
if (listen_fd == -1)
{
- warning ("could not create sync socket\n");
+ warning ("could not create sync socket");
break;
}
if (fd < 0)
{
- warning ("Accept returned %d, error: %s\n",
- fd, strerror (errno));
+ warning ("Accept returned %d, error: %s",
+ fd, safe_strerror (errno));
break;
}
if (ret == -1)
{
warning ("reading socket (fd=%d) failed with %s",
- fd, strerror (errno));
+ fd, safe_strerror (errno));
close (fd);
break;
}
}
#include <sys/mman.h>
-#include <fcntl.h>
IP_AGENT_EXPORT_VAR char *gdb_tp_heap_buffer;
IP_AGENT_EXPORT_VAR char *gdb_jump_pad_buffer;
projects / deliverable / binutils-gdb.git / blobdiff