static void
trace_save (const char *filename, struct trace_file_writer *writer,
int target_does_save)
{
struct trace_status *ts = current_trace_status ();
struct uploaded_tp *uploaded_tps = NULL, *utp;
struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
ULONGEST offset = 0;
#define MAX_TRACE_UPLOAD 2000
gdb_byte buf[MAX_TRACE_UPLOAD];
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
/* If the target is to save the data to a file on its own, then just
send the command and be done with it. */
if (target_does_save)
{
if (!writer->ops->target_save (writer, filename))
error (_("Target failed to save trace data to '%s'."),
filename);
return;
}
/* Get the trace status first before opening the file, so if the
target is losing, we can get out without touching files. Since
we're just calling this for side effects, we ignore the
result. */
target_get_trace_status (ts);
writer->ops->start (writer, filename);
writer->ops->write_header (writer);
/* Write descriptive info. */
/* Write out the size of a register block. */
writer->ops->write_regblock_type (writer, trace_regblock_size);
/* Write out the target description info. */
writer->ops->write_tdesc (writer);
/* Write out status of the tracing run (aka "tstatus" info). */
writer->ops->write_status (writer, ts);
/* Note that we want to upload tracepoints and save those, rather
than simply writing out the local ones, because the user may have
changed tracepoints in GDB in preparation for a future tracing
run, or maybe just mass-deleted all types of breakpoints as part
of cleaning up. So as not to contaminate the session, leave the
data in its uploaded form, don't make into real tracepoints. */
/* Get trace state variables first, they may be checked when parsing
uploaded commands. */
target_upload_trace_state_variables (&uploaded_tsvs);
for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
writer->ops->write_uploaded_tsv (writer, utsv);
free_uploaded_tsvs (&uploaded_tsvs);
target_upload_tracepoints (&uploaded_tps);
for (utp = uploaded_tps; utp; utp = utp->next)
target_get_tracepoint_status (NULL, utp);
for (utp = uploaded_tps; utp; utp = utp->next)
writer->ops->write_uploaded_tp (writer, utp);
free_uploaded_tps (&uploaded_tps);
/* Mark the end of the definition section. */
writer->ops->write_definition_end (writer);
/* Get and write the trace data proper. */
while (1)
{
LONGEST gotten = 0;
/* The writer supports writing the contents of trace buffer
directly to trace file. Don't parse the contents of trace
buffer. */
if (writer->ops->write_trace_buffer != NULL)
{
/* We ask for big blocks, in the hopes of efficiency, but
will take less if the target has packet size limitations
or some such. */
gotten = target_get_raw_trace_data (buf, offset,
MAX_TRACE_UPLOAD);
if (gotten < 0)
error (_("Failure to get requested trace buffer data"));
/* No more data is forthcoming, we're done. */
if (gotten == 0)
break;
writer->ops->write_trace_buffer (writer, buf, gotten);
offset += gotten;
}
else
{
uint16_t tp_num;
uint32_t tf_size;
/* Parse the trace buffers according to how data are stored
in trace buffer in GDBserver. */
gotten = target_get_raw_trace_data (buf, offset, 6);
if (gotten == 0)
break;
/* Read the first six bytes in, which is the tracepoint
number and trace frame size. */
tp_num = (uint16_t)
extract_unsigned_integer (&buf[0], 2, byte_order);
tf_size = (uint32_t)
extract_unsigned_integer (&buf[2], 4, byte_order);
writer->ops->frame_ops->start (writer, tp_num);
gotten = 6;
if (tf_size > 0)
{
unsigned int block;
offset += 6;
for (block = 0; block < tf_size; )
{
gdb_byte block_type;
/* We'll fetch one block each time, in order to
handle the extremely large 'M' block. We first
fetch one byte to get the type of the block. */
gotten = target_get_raw_trace_data (buf, offset, 1);
if (gotten < 1)
error (_("Failure to get requested trace buffer data"));
gotten = 1;
block += 1;
offset += 1;
block_type = buf[0];
switch (block_type)
{
case 'R':
gotten
= target_get_raw_trace_data (buf, offset,
trace_regblock_size);
if (gotten < trace_regblock_size)
error (_("Failure to get requested trace"
" buffer data"));
TRACE_WRITE_R_BLOCK (writer, buf,
trace_regblock_size);
break;
case 'M':
{
unsigned short mlen;
ULONGEST addr;
LONGEST t;
int j;
t = target_get_raw_trace_data (buf,offset, 10);
if (t < 10)
error (_("Failure to get requested trace"
" buffer data"));
offset += 10;
block += 10;
gotten = 0;
addr = (ULONGEST)
extract_unsigned_integer (buf, 8,
byte_order);
mlen = (unsigned short)
extract_unsigned_integer (&buf[8], 2,
byte_order);
TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
mlen);
/* The memory contents in 'M' block may be
very large. Fetch the data from the target
and write them into file one by one. */
for (j = 0; j < mlen; )
{
unsigned int read_length;
if (mlen - j > MAX_TRACE_UPLOAD)
read_length = MAX_TRACE_UPLOAD;
else
read_length = mlen - j;
t = target_get_raw_trace_data (buf,
offset + j,
read_length);
if (t < read_length)
error (_("Failure to get requested"
" trace buffer data"));
TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
read_length);
j += read_length;
gotten += read_length;
}
break;
}
case 'V':
{
int vnum;
LONGEST val;
gotten
= target_get_raw_trace_data (buf, offset,
12);
if (gotten < 12)
error (_("Failure to get requested"
" trace buffer data"));
vnum = (int) extract_signed_integer (buf,
4,
byte_order);
val
= extract_signed_integer (&buf[4], 8,
byte_order);
TRACE_WRITE_V_BLOCK (writer, vnum, val);
}
break;
default:
error (_("Unknown block type '%c' (0x%x) in"
" trace frame"),
block_type, block_type);
}
block += gotten;
offset += gotten;
}
}
else
offset += gotten;
writer->ops->frame_ops->end (writer);
}
}
writer->ops->end (writer);
}
static void
tfile_open (const char *arg, int from_tty)
{
char *temp;
struct cleanup *old_chain;
int flags;
int scratch_chan;
char header[TRACE_HEADER_SIZE];
char linebuf[1000]; /* Should be max remote packet size or so. */
gdb_byte byte;
int bytes, i;
struct trace_status *ts;
struct uploaded_tp *uploaded_tps = NULL;
struct uploaded_tsv *uploaded_tsvs = NULL;
char *filename;
target_preopen (from_tty);
if (!arg)
error (_("No trace file specified."));
filename = tilde_expand (arg);
if (!IS_ABSOLUTE_PATH(filename))
{
temp = concat (current_directory, "/", filename, (char *) NULL);
xfree (filename);
filename = temp;
}
old_chain = make_cleanup (xfree, filename);
flags = O_BINARY | O_LARGEFILE;
flags |= O_RDONLY;
scratch_chan = gdb_open_cloexec (filename, flags, 0);
if (scratch_chan < 0)
perror_with_name (filename);
/* Looks semi-reasonable. Toss the old trace file and work on the new. */
discard_cleanups (old_chain); /* Don't free filename any more. */
unpush_target (&tfile_ops);
trace_filename = xstrdup (filename);
trace_fd = scratch_chan;
/* Make sure this is clear. */
buffer_free (&trace_tdesc);
bytes = 0;
/* Read the file header and test for validity. */
tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
bytes += TRACE_HEADER_SIZE;
if (!(header[0] == 0x7f
&& (startswith (header + 1, "TRACE0\n"))))
error (_("File is not a valid trace file."));
push_target (&tfile_ops);
trace_regblock_size = 0;
ts = current_trace_status ();
/* We know we're working with a file. Record its name. */
ts->filename = trace_filename;
/* Set defaults in case there is no status line. */
ts->running_known = 0;
ts->stop_reason = trace_stop_reason_unknown;
ts->traceframe_count = -1;
ts->buffer_free = 0;
ts->disconnected_tracing = 0;
ts->circular_buffer = 0;
TRY
{
/* Read through a section of newline-terminated lines that
define things like tracepoints. */
i = 0;
while (1)
{
tfile_read (&byte, 1);
++bytes;
if (byte == '\n')
{
/* Empty line marks end of the definition section. */
if (i == 0)
break;
linebuf[i] = '\0';
i = 0;
tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
}
else
linebuf[i++] = byte;
if (i >= 1000)
error (_("Excessively long lines in trace file"));
}
/* By now, tdesc lines have been read from tfile - let's parse them. */
target_find_description ();
/* Record the starting offset of the binary trace data. */
trace_frames_offset = bytes;
/* If we don't have a blocksize, we can't interpret the
traceframes. */
if (trace_regblock_size == 0)
error (_("No register block size recorded in trace file"));
}
CATCH (ex, RETURN_MASK_ALL)
{
/* Remove the partially set up target. */
unpush_target (&tfile_ops);
throw_exception (ex);
}
static void
ctf_open (const char *dirname, int from_tty)
{
struct bt_ctf_event *event;
uint32_t event_id;
const struct bt_definition *scope;
struct uploaded_tsv *uploaded_tsvs = NULL;
struct uploaded_tp *uploaded_tps = NULL;
if (!dirname)
error (_("No CTF directory specified."));
ctf_open_dir (dirname);
target_preopen (from_tty);
/* Skip the first packet which about the trace status. The first
event is "frame". */
event = bt_ctf_iter_read_event (ctf_iter);
scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
if (event_id != CTF_EVENT_ID_FRAME)
error (_("Wrong event id of the first event"));
/* The second event is "status". */
bt_iter_next (bt_ctf_get_iter (ctf_iter));
event = bt_ctf_iter_read_event (ctf_iter);
scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
if (event_id != CTF_EVENT_ID_STATUS)
error (_("Wrong event id of the second event"));
ctf_read_status (event, current_trace_status ());
ctf_read_tsv (&uploaded_tsvs);
ctf_read_tp (&uploaded_tps);
event = bt_ctf_iter_read_event (ctf_iter);
/* EVENT can be NULL if we've already gone to the end of stream of
events. */
if (event != NULL)
{
scope = bt_ctf_get_top_level_scope (event,
BT_STREAM_EVENT_HEADER);
event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
scope, "id"));
if (event_id != CTF_EVENT_ID_FRAME)
error (_("Wrong event id of the first event of the second packet"));
}
start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
gdb_assert (start_pos->type == BT_SEEK_RESTORE);
trace_dirname = xstrdup (dirname);
push_target (&ctf_ops);
inferior_appeared (current_inferior (), CTF_PID);
inferior_ptid = pid_to_ptid (CTF_PID);
add_thread_silent (inferior_ptid);
merge_uploaded_trace_state_variables (&uploaded_tsvs);
merge_uploaded_tracepoints (&uploaded_tps);
post_create_inferior (&ctf_ops, from_tty);
}
