1 /* Trace file support in GDB.
3 Copyright (C) 1997-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "tracefile.h"
26 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
27 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
28 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
29 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
31 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
32 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
34 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
35 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
37 /* Free trace file writer. */
40 trace_file_writer_xfree (void *arg
)
42 struct trace_file_writer
*writer
= arg
;
44 writer
->ops
->dtor (writer
);
48 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
49 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
50 the save is performed on the target, otherwise GDB obtains all trace
51 data and saves it locally. */
54 trace_save (const char *filename
, struct trace_file_writer
*writer
,
57 struct trace_status
*ts
= current_trace_status ();
59 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
60 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
63 #define MAX_TRACE_UPLOAD 2000
64 gdb_byte buf
[MAX_TRACE_UPLOAD
];
66 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
68 /* If the target is to save the data to a file on its own, then just
69 send the command and be done with it. */
72 if (!writer
->ops
->target_save (writer
, filename
))
73 error (_("Target failed to save trace data to '%s'."),
78 /* Get the trace status first before opening the file, so if the
79 target is losing, we can get out without touching files. */
80 status
= target_get_trace_status (ts
);
82 writer
->ops
->start (writer
, filename
);
84 writer
->ops
->write_header (writer
);
86 /* Write descriptive info. */
88 /* Write out the size of a register block. */
89 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
91 /* Write out status of the tracing run (aka "tstatus" info). */
92 writer
->ops
->write_status (writer
, ts
);
94 /* Note that we want to upload tracepoints and save those, rather
95 than simply writing out the local ones, because the user may have
96 changed tracepoints in GDB in preparation for a future tracing
97 run, or maybe just mass-deleted all types of breakpoints as part
98 of cleaning up. So as not to contaminate the session, leave the
99 data in its uploaded form, don't make into real tracepoints. */
101 /* Get trace state variables first, they may be checked when parsing
102 uploaded commands. */
104 target_upload_trace_state_variables (&uploaded_tsvs
);
106 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
107 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
109 free_uploaded_tsvs (&uploaded_tsvs
);
111 target_upload_tracepoints (&uploaded_tps
);
113 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
114 target_get_tracepoint_status (NULL
, utp
);
116 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
117 writer
->ops
->write_uploaded_tp (writer
, utp
);
119 free_uploaded_tps (&uploaded_tps
);
121 /* Mark the end of the definition section. */
122 writer
->ops
->write_definition_end (writer
);
124 /* Get and write the trace data proper. */
129 /* The writer supports writing the contents of trace buffer
130 directly to trace file. Don't parse the contents of trace
132 if (writer
->ops
->write_trace_buffer
!= NULL
)
134 /* We ask for big blocks, in the hopes of efficiency, but
135 will take less if the target has packet size limitations
137 gotten
= target_get_raw_trace_data (buf
, offset
,
140 error (_("Failure to get requested trace buffer data"));
141 /* No more data is forthcoming, we're done. */
145 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
153 /* Parse the trace buffers according to how data are stored
154 in trace buffer in GDBserver. */
156 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
161 /* Read the first six bytes in, which is the tracepoint
162 number and trace frame size. */
164 extract_unsigned_integer (&buf
[0], 2, byte_order
);
167 extract_unsigned_integer (&buf
[2], 4, byte_order
);
169 writer
->ops
->frame_ops
->start (writer
, tp_num
);
178 for (block
= 0; block
< tf_size
; )
182 /* We'll fetch one block each time, in order to
183 handle the extremely large 'M' block. We first
184 fetch one byte to get the type of the block. */
185 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
187 error (_("Failure to get requested trace buffer data"));
198 = target_get_raw_trace_data (buf
, offset
,
199 trace_regblock_size
);
200 if (gotten
< trace_regblock_size
)
201 error (_("Failure to get requested trace"
204 TRACE_WRITE_R_BLOCK (writer
, buf
,
205 trace_regblock_size
);
214 t
= target_get_raw_trace_data (buf
,offset
, 10);
216 error (_("Failure to get requested trace"
224 extract_unsigned_integer (buf
, 8,
226 mlen
= (unsigned short)
227 extract_unsigned_integer (&buf
[8], 2,
230 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
233 /* The memory contents in 'M' block may be
234 very large. Fetch the data from the target
235 and write them into file one by one. */
236 for (j
= 0; j
< mlen
; )
238 unsigned int read_length
;
240 if (mlen
- j
> MAX_TRACE_UPLOAD
)
241 read_length
= MAX_TRACE_UPLOAD
;
243 read_length
= mlen
- j
;
245 t
= target_get_raw_trace_data (buf
,
249 error (_("Failure to get requested"
250 " trace buffer data"));
252 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
256 gotten
+= read_length
;
267 = target_get_raw_trace_data (buf
, offset
,
270 error (_("Failure to get requested"
271 " trace buffer data"));
273 vnum
= (int) extract_signed_integer (buf
,
277 = extract_signed_integer (&buf
[4], 8,
280 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
284 error (_("Unknown block type '%c' (0x%x) in"
286 block_type
, block_type
);
296 writer
->ops
->frame_ops
->end (writer
);
300 writer
->ops
->end (writer
);
304 trace_save_command (char *args
, int from_tty
)
306 int target_does_save
= 0;
308 char *filename
= NULL
;
309 struct cleanup
*back_to
;
310 int generate_ctf
= 0;
311 struct trace_file_writer
*writer
= NULL
;
314 error_no_arg (_("file in which to save trace data"));
316 argv
= gdb_buildargv (args
);
317 back_to
= make_cleanup_freeargv (argv
);
319 for (; *argv
; ++argv
)
321 if (strcmp (*argv
, "-r") == 0)
322 target_does_save
= 1;
323 if (strcmp (*argv
, "-ctf") == 0)
325 else if (**argv
== '-')
326 error (_("unknown option `%s'"), *argv
);
332 error_no_arg (_("file in which to save trace data"));
335 writer
= ctf_trace_file_writer_new ();
337 writer
= tfile_trace_file_writer_new ();
339 make_cleanup (trace_file_writer_xfree
, writer
);
341 trace_save (filename
, writer
, target_does_save
);
344 printf_filtered (_("Trace data saved to %s '%s'.\n"),
345 generate_ctf
? "directory" : "file", filename
);
347 do_cleanups (back_to
);
350 /* Save the trace data to file FILENAME of tfile format. */
353 trace_save_tfile (const char *filename
, int target_does_save
)
355 struct trace_file_writer
*writer
;
356 struct cleanup
*back_to
;
358 writer
= tfile_trace_file_writer_new ();
359 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
360 trace_save (filename
, writer
, target_does_save
);
361 do_cleanups (back_to
);
364 /* Save the trace data to dir DIRNAME of ctf format. */
367 trace_save_ctf (const char *dirname
, int target_does_save
)
369 struct trace_file_writer
*writer
;
370 struct cleanup
*back_to
;
372 writer
= ctf_trace_file_writer_new ();
373 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
375 trace_save (dirname
, writer
, target_does_save
);
376 do_cleanups (back_to
);
379 /* This is the implementation of target_ops method to_has_all_memory. */
382 tracefile_has_all_memory (struct target_ops
*ops
)
387 /* This is the implementation of target_ops method to_has_memory. */
390 tracefile_has_memory (struct target_ops
*ops
)
395 /* This is the implementation of target_ops method to_has_stack.
396 The target has a stack when GDB has already selected one trace
400 tracefile_has_stack (struct target_ops
*ops
)
402 return get_traceframe_number () != -1;
405 /* This is the implementation of target_ops method to_has_registers.
406 The target has registers when GDB has already selected one trace
410 tracefile_has_registers (struct target_ops
*ops
)
412 return get_traceframe_number () != -1;
415 /* This is the implementation of target_ops method to_thread_alive.
416 tracefile has one thread faked by GDB. */
419 tracefile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
424 /* This is the implementation of target_ops method to_get_trace_status.
425 The trace status for a file is that tracing can never be run. */
428 tracefile_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
430 /* Other bits of trace status were collected as part of opening the
431 trace files, so nothing to do here. */
436 /* Initialize OPS for tracefile related targets. */
439 init_tracefile_ops (struct target_ops
*ops
)
441 ops
->to_stratum
= process_stratum
;
442 ops
->to_get_trace_status
= tracefile_get_trace_status
;
443 ops
->to_has_all_memory
= tracefile_has_all_memory
;
444 ops
->to_has_memory
= tracefile_has_memory
;
445 ops
->to_has_stack
= tracefile_has_stack
;
446 ops
->to_has_registers
= tracefile_has_registers
;
447 ops
->to_thread_alive
= tracefile_thread_alive
;
448 ops
->to_magic
= OPS_MAGIC
;
451 extern initialize_file_ftype _initialize_tracefile
;
454 _initialize_tracefile (void)
456 add_com ("tsave", class_trace
, trace_save_command
, _("\
457 Save the trace data to a file.\n\
458 Use the '-ctf' option to save the data to CTF format.\n\
459 Use the '-r' option to direct the target to save directly to the file,\n\
460 using its own filesystem."));