GDB (xrefs)

/tmp/gdb-8.1/gdb/tracefile.c
Go to the documentation of this file.
1 /* Trace file support in GDB.
2
3 Copyright (C) 1997-2018 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 #include "defs.h"
21 #include "tracefile.h"
22 #include "ctf.h"
23 #include "exec.h"
24 #include "regcache.h"
25
26 /* Helper macros. */
27
28 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
29 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
30 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
31 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
32 (size))
33 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
34 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
35 (size))
36 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
37 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
38
39 /* Free trace file writer. */
40
41 static void
42 trace_file_writer_xfree (void *arg)
43 {
44 struct trace_file_writer *writer = (struct trace_file_writer *) arg;
45
46 writer->ops->dtor (writer);
47 xfree (writer);
48 }
49
50 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
51 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
52 the save is performed on the target, otherwise GDB obtains all trace
53 data and saves it locally. */
54
55 static void
56 trace_save (const char *filename, struct trace_file_writer *writer,
57 int target_does_save)
58 {
59 struct trace_status *ts = current_trace_status ();
60 struct uploaded_tp *uploaded_tps = NULL, *utp;
61 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
62
63 ULONGEST offset = 0;
64 #define MAX_TRACE_UPLOAD 2000
65 gdb_byte buf[MAX_TRACE_UPLOAD];
66 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
67
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. */
70 if (target_does_save)
71 {
72 if (!writer->ops->target_save (writer, filename))
73 error (_("Target failed to save trace data to '%s'."),
74 filename);
75 return;
76 }
77
78 /* Get the trace status first before opening the file, so if the
79 target is losing, we can get out without touching files. Since
80 we're just calling this for side effects, we ignore the
81 result. */
82 target_get_trace_status (ts);
83
84 writer->ops->start (writer, filename);
85
86 writer->ops->write_header (writer);
87
88 /* Write descriptive info. */
89
90 /* Write out the size of a register block. */
91 writer->ops->write_regblock_type (writer, trace_regblock_size);
92
93 /* Write out the target description info. */
94 writer->ops->write_tdesc (writer);
95
96 /* Write out status of the tracing run (aka "tstatus" info). */
97 writer->ops->write_status (writer, ts);
98
99 /* Note that we want to upload tracepoints and save those, rather
100 than simply writing out the local ones, because the user may have
101 changed tracepoints in GDB in preparation for a future tracing
102 run, or maybe just mass-deleted all types of breakpoints as part
103 of cleaning up. So as not to contaminate the session, leave the
104 data in its uploaded form, don't make into real tracepoints. */
105
106 /* Get trace state variables first, they may be checked when parsing
107 uploaded commands. */
108
109 target_upload_trace_state_variables (&uploaded_tsvs);
110
111 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
112 writer->ops->write_uploaded_tsv (writer, utsv);
113
114 free_uploaded_tsvs (&uploaded_tsvs);
115
116 target_upload_tracepoints (&uploaded_tps);
117
118 for (utp = uploaded_tps; utp; utp = utp->next)
119 target_get_tracepoint_status (NULL, utp);
120
121 for (utp = uploaded_tps; utp; utp = utp->next)
122 writer->ops->write_uploaded_tp (writer, utp);
123
124 free_uploaded_tps (&uploaded_tps);
125
126 /* Mark the end of the definition section. */
127 writer->ops->write_definition_end (writer);
128
129 /* Get and write the trace data proper. */
130 while (1)
131 {
132 LONGEST gotten = 0;
133
134 /* The writer supports writing the contents of trace buffer
135 directly to trace file. Don't parse the contents of trace
136 buffer. */
137 if (writer->ops->write_trace_buffer != NULL)
138 {
139 /* We ask for big blocks, in the hopes of efficiency, but
140 will take less if the target has packet size limitations
141 or some such. */
142 gotten = target_get_raw_trace_data (buf, offset,
143 MAX_TRACE_UPLOAD);
144 if (gotten < 0)
145 error (_("Failure to get requested trace buffer data"));
146 /* No more data is forthcoming, we're done. */
147 if (gotten == 0)
148 break;
149
150 writer->ops->write_trace_buffer (writer, buf, gotten);
151
152 offset += gotten;
153 }
154 else
155 {
156 uint16_t tp_num;
157 uint32_t tf_size;
158 /* Parse the trace buffers according to how data are stored
159 in trace buffer in GDBserver. */
160
161 gotten = target_get_raw_trace_data (buf, offset, 6);
162
163 if (gotten == 0)
164 break;
165
166 /* Read the first six bytes in, which is the tracepoint
167 number and trace frame size. */
168 tp_num = (uint16_t)
169 extract_unsigned_integer (&buf[0], 2, byte_order);
170
171 tf_size = (uint32_t)
172 extract_unsigned_integer (&buf[2], 4, byte_order);
173
174 writer->ops->frame_ops->start (writer, tp_num);
175 gotten = 6;
176
177 if (tf_size > 0)
178 {
179 unsigned int block;
180
181 offset += 6;
182
183 for (block = 0; block < tf_size; )
184 {
185 gdb_byte block_type;
186
187 /* We'll fetch one block each time, in order to
188 handle the extremely large 'M' block. We first
189 fetch one byte to get the type of the block. */
190 gotten = target_get_raw_trace_data (buf, offset, 1);
191 if (gotten < 1)
192 error (_("Failure to get requested trace buffer data"));
193
194 gotten = 1;
195 block += 1;
196 offset += 1;
197
198 block_type = buf[0];
199 switch (block_type)
200 {
201 case 'R':
202 gotten
203 = target_get_raw_trace_data (buf, offset,
204 trace_regblock_size);
205 if (gotten < trace_regblock_size)
206 error (_("Failure to get requested trace"
207 " buffer data"));
208
209 TRACE_WRITE_R_BLOCK (writer, buf,
210 trace_regblock_size);
211 break;
212 case 'M':
213 {
214 unsigned short mlen;
215 ULONGEST addr;
216 LONGEST t;
217 int j;
218
219 t = target_get_raw_trace_data (buf,offset, 10);
220 if (t < 10)
221 error (_("Failure to get requested trace"
222 " buffer data"));
223
224 offset += 10;
225 block += 10;
226
227 gotten = 0;
228 addr = (ULONGEST)
229 extract_unsigned_integer (buf, 8,
230 byte_order);
231 mlen = (unsigned short)
232 extract_unsigned_integer (&buf[8], 2,
233 byte_order);
234
235 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
236 mlen);
237
238 /* The memory contents in 'M' block may be
239 very large. Fetch the data from the target
240 and write them into file one by one. */
241 for (j = 0; j < mlen; )
242 {
243 unsigned int read_length;
244
245 if (mlen - j > MAX_TRACE_UPLOAD)
246 read_length = MAX_TRACE_UPLOAD;
247 else
248 read_length = mlen - j;
249
250 t = target_get_raw_trace_data (buf,
251 offset + j,
252 read_length);
253 if (t < read_length)
254 error (_("Failure to get requested"
255 " trace buffer data"));
256
257 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
258 read_length);
259
260 j += read_length;
261 gotten += read_length;
262 }
263
264 break;
265 }
266 case 'V':
267 {
268 int vnum;
269 LONGEST val;
270
271 gotten
272 = target_get_raw_trace_data (buf, offset,
273 12);
274 if (gotten < 12)
275 error (_("Failure to get requested"
276 " trace buffer data"));
277
278 vnum = (int) extract_signed_integer (buf,
279 4,
280 byte_order);
281 val
282 = extract_signed_integer (&buf[4], 8,
283 byte_order);
284
285 TRACE_WRITE_V_BLOCK (writer, vnum, val);
286 }
287 break;
288 default:
289 error (_("Unknown block type '%c' (0x%x) in"
290 " trace frame"),
291 block_type, block_type);
292 }
293
294 block += gotten;
295 offset += gotten;
296 }
297 }
298 else
299 offset += gotten;
300
301 writer->ops->frame_ops->end (writer);
302 }
303 }
304
305 writer->ops->end (writer);
306 }
307
308 static void
309 tsave_command (const char *args, int from_tty)
310 {
311 int target_does_save = 0;
312 char **argv;
313 char *filename = NULL;
314 struct cleanup *back_to;
315 int generate_ctf = 0;
316 struct trace_file_writer *writer = NULL;
317
318 if (args == NULL)
319 error_no_arg (_("file in which to save trace data"));
320
321 gdb_argv built_argv (args);
322 argv = built_argv.get ();
323
324 for (; *argv; ++argv)
325 {
326 if (strcmp (*argv, "-r") == 0)
327 target_does_save = 1;
328 else if (strcmp (*argv, "-ctf") == 0)
329 generate_ctf = 1;
330 else if (**argv == '-')
331 error (_("unknown option `%s'"), *argv);
332 else
333 filename = *argv;
334 }
335
336 if (!filename)
337 error_no_arg (_("file in which to save trace data"));
338
339 if (generate_ctf)
340 writer = ctf_trace_file_writer_new ();
341 else
342 writer = tfile_trace_file_writer_new ();
343
344 back_to = make_cleanup (trace_file_writer_xfree, writer);
345
346 trace_save (filename, writer, target_does_save);
347
348 if (from_tty)
349 printf_filtered (_("Trace data saved to %s '%s'.\n"),
350 generate_ctf ? "directory" : "file", filename);
351
352 do_cleanups (back_to);
353 }
354
355 /* Save the trace data to file FILENAME of tfile format. */
356
357 void
358 trace_save_tfile (const char *filename, int target_does_save)
359 {
360 struct trace_file_writer *writer;
361 struct cleanup *back_to;
362
363 writer = tfile_trace_file_writer_new ();
364 back_to = make_cleanup (trace_file_writer_xfree, writer);
365 trace_save (filename, writer, target_does_save);
366 do_cleanups (back_to);
367 }
368
369 /* Save the trace data to dir DIRNAME of ctf format. */
370
371 void
372 trace_save_ctf (const char *dirname, int target_does_save)
373 {
374 struct trace_file_writer *writer;
375 struct cleanup *back_to;
376
377 writer = ctf_trace_file_writer_new ();
378 back_to = make_cleanup (trace_file_writer_xfree, writer);
379
380 trace_save (dirname, writer, target_does_save);
381 do_cleanups (back_to);
382 }
383
384 /* Fetch register data from tracefile, shared for both tfile and
385 ctf. */
386
387 void
388 tracefile_fetch_registers (struct regcache *regcache, int regno)
389 {
390 struct gdbarch *gdbarch = regcache->arch ();
391 struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
392 int regn;
393
394 /* We get here if no register data has been found. Mark registers
395 as unavailable. */
396 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
397 regcache_raw_supply (regcache, regn, NULL);
398
399 /* We can often usefully guess that the PC is going to be the same
400 as the address of the tracepoint. */
401 if (tp == NULL || tp->loc == NULL)
402 return;
403
404 /* But don't try to guess if tracepoint is multi-location... */
405 if (tp->loc->next)
406 {
407 warning (_("Tracepoint %d has multiple "
408 "locations, cannot infer $pc"),
409 tp->number);
410 return;
411 }
412 /* ... or does while-stepping. */
413 else if (tp->step_count > 0)
414 {
415 warning (_("Tracepoint %d does while-stepping, "
416 "cannot infer $pc"),
417 tp->number);
418 return;
419 }
420
421 /* Guess what we can from the tracepoint location. */
422 gdbarch_guess_tracepoint_registers (gdbarch, regcache,
423 tp->loc->address);
424 }
425
426 /* This is the implementation of target_ops method to_has_all_memory. */
427
428 static int
429 tracefile_has_all_memory (struct target_ops *ops)
430 {
431 return 1;
432 }
433
434 /* This is the implementation of target_ops method to_has_memory. */
435
436 static int
437 tracefile_has_memory (struct target_ops *ops)
438 {
439 return 1;
440 }
441
442 /* This is the implementation of target_ops method to_has_stack.
443 The target has a stack when GDB has already selected one trace
444 frame. */
445
446 static int
447 tracefile_has_stack (struct target_ops *ops)
448 {
449 return get_traceframe_number () != -1;
450 }
451
452 /* This is the implementation of target_ops method to_has_registers.
453 The target has registers when GDB has already selected one trace
454 frame. */
455
456 static int
457 tracefile_has_registers (struct target_ops *ops)
458 {
459 return get_traceframe_number () != -1;
460 }
461
462 /* This is the implementation of target_ops method to_thread_alive.
463 tracefile has one thread faked by GDB. */
464
465 static int
466 tracefile_thread_alive (struct target_ops *ops, ptid_t ptid)
467 {
468 return 1;
469 }
470
471 /* This is the implementation of target_ops method to_get_trace_status.
472 The trace status for a file is that tracing can never be run. */
473
474 static int
475 tracefile_get_trace_status (struct target_ops *self, struct trace_status *ts)
476 {
477 /* Other bits of trace status were collected as part of opening the
478 trace files, so nothing to do here. */
479
480 return -1;
481 }
482
483 /* Initialize OPS for tracefile related targets. */
484
485 void
486 init_tracefile_ops (struct target_ops *ops)
487 {
488 ops->to_stratum = process_stratum;
489 ops->to_get_trace_status = tracefile_get_trace_status;
490 ops->to_has_all_memory = tracefile_has_all_memory;
491 ops->to_has_memory = tracefile_has_memory;
492 ops->to_has_stack = tracefile_has_stack;
493 ops->to_has_registers = tracefile_has_registers;
494 ops->to_thread_alive = tracefile_thread_alive;
495 ops->to_magic = OPS_MAGIC;
496 }
497
498 void
499 _initialize_tracefile (void)
500 {
501 add_com ("tsave", class_trace, tsave_command, _("\
502 Save the trace data to a file.\n\
503 Use the '-ctf' option to save the data to CTF format.\n\
504 Use the '-r' option to direct the target to save directly to the file,\n\
505 using its own filesystem."));
506 }
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
breakpoint::loc
bp_location * loc
Definition: breakpoint.h:702
trace_regblock_size
int trace_regblock_size
Definition: tracefile-tfile.c:396
xfree
void xfree(void *)
target_upload_trace_state_variables
#define target_upload_trace_state_variables(utsvp)
Definition: target.h:2175
trace_file_writer::ops
const struct trace_file_write_ops * ops
Definition: tracefile.h:111
warning
void warning(const char *fmt,...)
Definition: errors.c:26
tracepoint
Definition: breakpoint.h:874
trace_file_write_ops::write_status
void(* write_status)(struct trace_file_writer *self, struct trace_status *ts)
Definition: tracefile.h:76
free_uploaded_tps
void free_uploaded_tps(struct uploaded_tp **utpp)
Definition: tracepoint.c:3078
target_get_raw_trace_data
#define target_get_raw_trace_data(buf, offset, len)
Definition: target.h:2178
breakpoint::number
int number
Definition: breakpoint.h:699
TRACE_WRITE_M_BLOCK_HEADER
#define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size)
Definition: tracefile.c:30
tracefile_has_registers
static int tracefile_has_registers(struct target_ops *ops)
Definition: tracefile.c:457
tracefile_has_stack
static int tracefile_has_stack(struct target_ops *ops)
Definition: tracefile.c:447
breakpoint::ops
const breakpoint_ops * ops
Definition: breakpoint.h:689
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
get_tracepoint
struct tracepoint * get_tracepoint(int num)
Definition: breakpoint.c:15018
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
trace_file_write_ops::start
void(* start)(struct trace_file_writer *self, const char *name)
Definition: tracefile.h:64
defs.h
target_get_tracepoint_status
#define target_get_tracepoint_status(tp, utp)
Definition: target.h:2155
free_uploaded_tsvs
void free_uploaded_tsvs(struct uploaded_tsv **utsvp)
Definition: tracepoint.c:3111
trace_file_write_ops::write_regblock_type
void(* write_regblock_type)(struct trace_file_writer *self, int size)
Definition: tracefile.h:72
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
trace_file_write_ops::frame_ops
const struct trace_frame_write_ops * frame_ops
Definition: tracefile.h:101
tracepoint::step_count
long step_count
Definition: breakpoint.h:878
_initialize_tracefile
void _initialize_tracefile(void)
Definition: tracefile.c:499
current_trace_status
struct trace_status * current_trace_status(void)
Definition: tracepoint.c:189
gdb_argv
Definition: utils.h:128
trace_save_ctf
void trace_save_ctf(const char *dirname, int target_does_save)
Definition: tracefile.c:372
OPS_MAGIC
#define OPS_MAGIC
Definition: target.h:1270
uploaded_tsv::next
struct uploaded_tsv * next
Definition: tracepoint.h:210
target_ops
Definition: target.h:412
tracefile.h
trace_status
Definition: tracepoint.h:88
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
trace_frame_write_ops::end
void(* end)(struct trace_file_writer *self)
Definition: tracefile.h:46
class_trace
Definition: command.h:42
regcache.h
TRACE_WRITE_V_BLOCK
#define TRACE_WRITE_V_BLOCK(writer, num, val)
Definition: tracefile.c:36
ptid_t
Definition: ptid.h:35
uploaded_tp::next
struct uploaded_tp * next
Definition: tracepoint.h:199
block_type
block_type
Definition: mdebugread.c:235
tracefile_has_all_memory
static int tracefile_has_all_memory(struct target_ops *ops)
Definition: tracefile.c:429
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
init_tracefile_ops
void init_tracefile_ops(struct target_ops *ops)
Definition: tracefile.c:486
get_traceframe_number
int get_traceframe_number(void)
Definition: tracepoint.c:2976
trace_file_write_ops::write_uploaded_tsv
void(* write_uploaded_tsv)(struct trace_file_writer *self, struct uploaded_tsv *tsv)
Definition: tracefile.h:80
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
bp_location::next
bp_location * next
Definition: breakpoint.h:324
process_stratum
Definition: target.h:87
ctf.h
block
Definition: block.h:60
bp_location::address
CORE_ADDR address
Definition: breakpoint.h:427
TRACE_WRITE_R_BLOCK
#define TRACE_WRITE_R_BLOCK(writer, buf, size)
Definition: tracefile.c:28
tracefile_thread_alive
static int tracefile_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: tracefile.c:466
trace_save
static void trace_save(const char *filename, struct trace_file_writer *writer, int target_does_save)
Definition: tracefile.c:56
target_get_trace_status
#define target_get_trace_status(ts)
Definition: target.h:2152
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
get_tracepoint_number
int get_tracepoint_number(void)
Definition: tracepoint.c:2982
tracefile_fetch_registers
void tracefile_fetch_registers(struct regcache *regcache, int regno)
Definition: tracefile.c:388
trace_file_write_ops::write_header
void(* write_header)(struct trace_file_writer *self)
Definition: tracefile.h:68
trace_file_write_ops::dtor
void(* dtor)(struct trace_file_writer *self)
Definition: tracefile.h:55
exec.h
tracefile_get_trace_status
static int tracefile_get_trace_status(struct target_ops *self, struct trace_status *ts)
Definition: tracefile.c:475
uploaded_tsv
Definition: tracepoint.h:204
TRACE_WRITE_M_BLOCK_MEMORY
#define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size)
Definition: tracefile.c:33
offset
int offset
Definition: agent.c:65
trace_file_write_ops::write_definition_end
void(* write_definition_end)(struct trace_file_writer *self)
Definition: tracefile.h:91
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
ctf_trace_file_writer_new
struct trace_file_writer * ctf_trace_file_writer_new(void)
Definition: ctf.c:802
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
uploaded_tp
Definition: tracepoint.h:166
MAX_TRACE_UPLOAD
#define MAX_TRACE_UPLOAD
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
trace_frame_write_ops::start
void(* start)(struct trace_file_writer *self, uint16_t tpnum)
Definition: tracefile.h:14
trace_file_write_ops::write_tdesc
void(* write_tdesc)(struct trace_file_writer *self)
Definition: tracefile.h:88
trace_save_tfile
void trace_save_tfile(const char *filename, int target_does_save)
Definition: tracefile.c:358
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
trace_file_writer_xfree
static void trace_file_writer_xfree(void *arg)
Definition: tracefile.c:42
gdb_argv::get
char ** get()
Definition: utils.h:177
regcache
Definition: regcache.h:232
trace_file_write_ops::end
void(* end)(struct trace_file_writer *self)
Definition: tracefile.h:104
gdb.argv
argv
Definition: __init__.py:63
tfile_trace_file_writer_new
struct trace_file_writer * tfile_trace_file_writer_new(void)
Definition: tracefile-tfile.c:369
trace_file_write_ops::write_uploaded_tp
void(* write_uploaded_tp)(struct trace_file_writer *self, struct uploaded_tp *tp)
Definition: tracefile.h:84
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
trace_file_write_ops::write_trace_buffer
void(* write_trace_buffer)(struct trace_file_writer *self, gdb_byte *buf, LONGEST len)
Definition: tracefile.h:95
trace_file_writer
Definition: tracefile.h:109
gdbarch_guess_tracepoint_registers
void gdbarch_guess_tracepoint_registers(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
Definition: gdbarch.c:4670
error
void error(const char *fmt,...)
Definition: errors.c:38
tracefile_has_memory
static int tracefile_has_memory(struct target_ops *ops)
Definition: tracefile.c:437
trace_file_write_ops::target_save
int(* target_save)(struct trace_file_writer *self, const char *name)
Definition: tracefile.h:60
tsave_command
static void tsave_command(const char *args, int from_tty)
Definition: tracefile.c:309
LONGEST
long long LONGEST
Definition: common-types.h:52
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
target_upload_tracepoints
#define target_upload_tracepoints(utpp)
Definition: target.h:2172