1 /* Tracepoint code for remote server for GDB.
2 Copyright (C) 2009-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "tracepoint.h"
21 #include "gdbthread.h"
35 #define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
37 /* This file is built for both GDBserver, and the in-process
38 agent (IPA), a shared library that includes a tracing agent that is
39 loaded by the inferior to support fast tracepoints. Fast
40 tracepoints (or more accurately, jump based tracepoints) are
41 implemented by patching the tracepoint location with a jump into a
42 small trampoline function whose job is to save the register state,
43 call the in-process tracing agent, and then execute the original
44 instruction that was under the tracepoint jump (possibly adjusted,
45 if PC-relative, or some such).
47 The current synchronization design is pull based. That means,
48 GDBserver does most of the work, by peeking/poking at the inferior
49 agent's memory directly for downloading tracepoint and associated
50 objects, and for uploading trace frames. Whenever the IPA needs
51 something from GDBserver (trace buffer is full, tracing stopped for
52 some reason, etc.) the IPA calls a corresponding hook function
53 where GDBserver has placed a breakpoint.
55 Each of the agents has its own trace buffer. When browsing the
56 trace frames built from slow and fast tracepoints from GDB (tfind
57 mode), there's no guarantee the user is seeing the trace frames in
58 strict chronological creation order, although, GDBserver tries to
59 keep the order relatively reasonable, by syncing the trace buffers
64 #ifdef IN_PROCESS_AGENT
66 static void trace_vdebug (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
69 trace_vdebug (const char *fmt
, ...)
75 vsprintf (buf
, fmt
, ap
);
76 fprintf (stderr
, PROG
"/tracepoint: %s\n", buf
);
80 #define trace_debug_1(level, fmt, args...) \
82 if (level <= debug_threads) \
83 trace_vdebug ((fmt), ##args); \
88 #define trace_debug_1(level, fmt, args...) \
90 if (level <= debug_threads) \
92 debug_printf ((fmt), ##args); \
93 debug_printf ("\n"); \
99 #define trace_debug(FMT, args...) \
100 trace_debug_1 (1, FMT, ##args)
102 #if defined(__GNUC__)
103 # define ATTR_USED __attribute__((used))
104 # define ATTR_NOINLINE __attribute__((noinline))
105 # define ATTR_CONSTRUCTOR __attribute__ ((constructor))
108 # define ATTR_NOINLINE
109 # define ATTR_CONSTRUCTOR
112 /* Make sure the functions the IPA needs to export (symbols GDBserver
113 needs to query GDB about) are exported. */
115 #ifdef IN_PROCESS_AGENT
116 # if defined _WIN32 || defined __CYGWIN__
117 # define IP_AGENT_EXPORT __declspec(dllexport) ATTR_USED
120 # define IP_AGENT_EXPORT \
121 __attribute__ ((visibility("default"))) ATTR_USED
123 # define IP_AGENT_EXPORT ATTR_USED
127 # define IP_AGENT_EXPORT
130 /* Prefix exported symbols, for good citizenship. All the symbols
131 that need exporting are defined in this module. */
132 #ifdef IN_PROCESS_AGENT
133 # define gdb_tp_heap_buffer gdb_agent_gdb_tp_heap_buffer
134 # define gdb_jump_pad_buffer gdb_agent_gdb_jump_pad_buffer
135 # define gdb_jump_pad_buffer_end gdb_agent_gdb_jump_pad_buffer_end
136 # define gdb_trampoline_buffer gdb_agent_gdb_trampoline_buffer
137 # define gdb_trampoline_buffer_end gdb_agent_gdb_trampoline_buffer_end
138 # define gdb_trampoline_buffer_error gdb_agent_gdb_trampoline_buffer_error
139 # define collecting gdb_agent_collecting
140 # define gdb_collect gdb_agent_gdb_collect
141 # define stop_tracing gdb_agent_stop_tracing
142 # define flush_trace_buffer gdb_agent_flush_trace_buffer
143 # define about_to_request_buffer_space gdb_agent_about_to_request_buffer_space
144 # define trace_buffer_is_full gdb_agent_trace_buffer_is_full
145 # define stopping_tracepoint gdb_agent_stopping_tracepoint
146 # define expr_eval_result gdb_agent_expr_eval_result
147 # define error_tracepoint gdb_agent_error_tracepoint
148 # define tracepoints gdb_agent_tracepoints
149 # define tracing gdb_agent_tracing
150 # define trace_buffer_ctrl gdb_agent_trace_buffer_ctrl
151 # define trace_buffer_ctrl_curr gdb_agent_trace_buffer_ctrl_curr
152 # define trace_buffer_lo gdb_agent_trace_buffer_lo
153 # define trace_buffer_hi gdb_agent_trace_buffer_hi
154 # define traceframe_read_count gdb_agent_traceframe_read_count
155 # define traceframe_write_count gdb_agent_traceframe_write_count
156 # define traceframes_created gdb_agent_traceframes_created
157 # define trace_state_variables gdb_agent_trace_state_variables
158 # define get_raw_reg gdb_agent_get_raw_reg
159 # define get_trace_state_variable_value \
160 gdb_agent_get_trace_state_variable_value
161 # define set_trace_state_variable_value \
162 gdb_agent_set_trace_state_variable_value
163 # define ust_loaded gdb_agent_ust_loaded
164 # define helper_thread_id gdb_agent_helper_thread_id
165 # define cmd_buf gdb_agent_cmd_buf
168 #ifndef IN_PROCESS_AGENT
170 /* Addresses of in-process agent's symbols GDBserver cares about. */
172 struct ipa_sym_addresses
174 CORE_ADDR addr_gdb_tp_heap_buffer
;
175 CORE_ADDR addr_gdb_jump_pad_buffer
;
176 CORE_ADDR addr_gdb_jump_pad_buffer_end
;
177 CORE_ADDR addr_gdb_trampoline_buffer
;
178 CORE_ADDR addr_gdb_trampoline_buffer_end
;
179 CORE_ADDR addr_gdb_trampoline_buffer_error
;
180 CORE_ADDR addr_collecting
;
181 CORE_ADDR addr_gdb_collect
;
182 CORE_ADDR addr_stop_tracing
;
183 CORE_ADDR addr_flush_trace_buffer
;
184 CORE_ADDR addr_about_to_request_buffer_space
;
185 CORE_ADDR addr_trace_buffer_is_full
;
186 CORE_ADDR addr_stopping_tracepoint
;
187 CORE_ADDR addr_expr_eval_result
;
188 CORE_ADDR addr_error_tracepoint
;
189 CORE_ADDR addr_tracepoints
;
190 CORE_ADDR addr_tracing
;
191 CORE_ADDR addr_trace_buffer_ctrl
;
192 CORE_ADDR addr_trace_buffer_ctrl_curr
;
193 CORE_ADDR addr_trace_buffer_lo
;
194 CORE_ADDR addr_trace_buffer_hi
;
195 CORE_ADDR addr_traceframe_read_count
;
196 CORE_ADDR addr_traceframe_write_count
;
197 CORE_ADDR addr_traceframes_created
;
198 CORE_ADDR addr_trace_state_variables
;
199 CORE_ADDR addr_get_raw_reg
;
200 CORE_ADDR addr_get_trace_state_variable_value
;
201 CORE_ADDR addr_set_trace_state_variable_value
;
202 CORE_ADDR addr_ust_loaded
;
211 IPA_SYM(gdb_tp_heap_buffer
),
212 IPA_SYM(gdb_jump_pad_buffer
),
213 IPA_SYM(gdb_jump_pad_buffer_end
),
214 IPA_SYM(gdb_trampoline_buffer
),
215 IPA_SYM(gdb_trampoline_buffer_end
),
216 IPA_SYM(gdb_trampoline_buffer_error
),
218 IPA_SYM(gdb_collect
),
219 IPA_SYM(stop_tracing
),
220 IPA_SYM(flush_trace_buffer
),
221 IPA_SYM(about_to_request_buffer_space
),
222 IPA_SYM(trace_buffer_is_full
),
223 IPA_SYM(stopping_tracepoint
),
224 IPA_SYM(expr_eval_result
),
225 IPA_SYM(error_tracepoint
),
226 IPA_SYM(tracepoints
),
228 IPA_SYM(trace_buffer_ctrl
),
229 IPA_SYM(trace_buffer_ctrl_curr
),
230 IPA_SYM(trace_buffer_lo
),
231 IPA_SYM(trace_buffer_hi
),
232 IPA_SYM(traceframe_read_count
),
233 IPA_SYM(traceframe_write_count
),
234 IPA_SYM(traceframes_created
),
235 IPA_SYM(trace_state_variables
),
236 IPA_SYM(get_raw_reg
),
237 IPA_SYM(get_trace_state_variable_value
),
238 IPA_SYM(set_trace_state_variable_value
),
242 static struct ipa_sym_addresses ipa_sym_addrs
;
244 static int read_inferior_integer (CORE_ADDR symaddr
, int *val
);
246 /* Returns true if both the in-process agent library and the static
247 tracepoints libraries are loaded in the inferior, and agent has
248 capability on static tracepoints. */
251 in_process_agent_supports_ust (void)
255 if (!agent_loaded_p ())
257 warning ("In-process agent not loaded");
261 if (agent_capability_check (AGENT_CAPA_STATIC_TRACE
))
263 /* Agent understands static tracepoint, then check whether UST is in
264 fact loaded in the inferior. */
265 if (read_inferior_integer (ipa_sym_addrs
.addr_ust_loaded
, &loaded
))
267 warning ("Error reading ust_loaded in lib");
278 write_e_ipa_not_loaded (char *buffer
)
281 "E.In-process agent library not loaded in process. "
282 "Fast and static tracepoints unavailable.");
285 /* Write an error to BUFFER indicating that UST isn't loaded in the
289 write_e_ust_not_loaded (char *buffer
)
293 "E.UST library not loaded in process. "
294 "Static tracepoints unavailable.");
296 sprintf (buffer
, "E.GDBserver was built without static tracepoints support");
300 /* If the in-process agent library isn't loaded in the inferior, write
301 an error to BUFFER, and return 1. Otherwise, return 0. */
304 maybe_write_ipa_not_loaded (char *buffer
)
306 if (!agent_loaded_p ())
308 write_e_ipa_not_loaded (buffer
);
314 /* If the in-process agent library and the ust (static tracepoints)
315 library aren't loaded in the inferior, write an error to BUFFER,
316 and return 1. Otherwise, return 0. */
319 maybe_write_ipa_ust_not_loaded (char *buffer
)
321 if (!agent_loaded_p ())
323 write_e_ipa_not_loaded (buffer
);
326 else if (!in_process_agent_supports_ust ())
328 write_e_ust_not_loaded (buffer
);
334 /* Cache all future symbols that the tracepoints module might request.
335 We can not request symbols at arbitrary states in the remote
336 protocol, only when the client tells us that new symbols are
337 available. So when we load the in-process library, make sure to
338 check the entire list. */
341 tracepoint_look_up_symbols (void)
345 if (agent_loaded_p ())
348 for (i
= 0; i
< sizeof (symbol_list
) / sizeof (symbol_list
[0]); i
++)
351 (CORE_ADDR
*) ((char *) &ipa_sym_addrs
+ symbol_list
[i
].offset
);
353 if (look_up_one_symbol (symbol_list
[i
].name
, addrp
, 1) == 0)
356 debug_printf ("symbol `%s' not found\n", symbol_list
[i
].name
);
361 agent_look_up_symbols (NULL
);
366 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
367 of the "stop_tracing" function. When this breakpoint is hit,
368 tracing stopped in the IPA for some reason. E.g., due to
369 tracepoint reaching the pass count, hitting conditional expression
370 evaluation error, etc.
372 The IPA's trace buffer is never in circular tracing mode: instead,
373 GDBserver's is, and whenever the in-process buffer fills, it calls
374 "flush_trace_buffer", which triggers an internal breakpoint.
375 GDBserver reacts to this breakpoint by pulling the meanwhile
376 collected data. Old frames discarding is always handled on the
379 #ifdef IN_PROCESS_AGENT
381 read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
383 memcpy (myaddr
, (void *) (uintptr_t) memaddr
, len
);
387 /* Call this in the functions where GDBserver places a breakpoint, so
388 that the compiler doesn't try to be clever and skip calling the
389 function at all. This is necessary, even if we tell the compiler
390 to not inline said functions. */
392 #if defined(__GNUC__)
393 # define UNKNOWN_SIDE_EFFECTS() asm ("")
395 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
398 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
401 /* GDBserver places breakpoint here. */
402 UNKNOWN_SIDE_EFFECTS();
405 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
406 flush_trace_buffer (void)
408 /* GDBserver places breakpoint here. */
409 UNKNOWN_SIDE_EFFECTS();
414 #ifndef IN_PROCESS_AGENT
416 tracepoint_handler (CORE_ADDR address
)
418 trace_debug ("tracepoint_handler: tracepoint at 0x%s hit",
423 /* Breakpoint at "stop_tracing" in the inferior lib. */
424 struct breakpoint
*stop_tracing_bkpt
;
425 static int stop_tracing_handler (CORE_ADDR
);
427 /* Breakpoint at "flush_trace_buffer" in the inferior lib. */
428 struct breakpoint
*flush_trace_buffer_bkpt
;
429 static int flush_trace_buffer_handler (CORE_ADDR
);
431 static void download_trace_state_variables (void);
432 static void upload_fast_traceframes (void);
434 static int run_inferior_command (char *cmd
, int len
);
437 read_inferior_integer (CORE_ADDR symaddr
, int *val
)
439 return read_inferior_memory (symaddr
, (unsigned char *) val
,
444 static int tracepoint_send_agent (struct tracepoint
*tpoint
);
447 read_inferior_uinteger (CORE_ADDR symaddr
, unsigned int *val
)
449 return read_inferior_memory (symaddr
, (unsigned char *) val
,
454 read_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR
*val
)
456 void *pval
= (void *) (uintptr_t) val
;
459 ret
= read_inferior_memory (symaddr
, (unsigned char *) &pval
, sizeof (pval
));
460 *val
= (uintptr_t) pval
;
465 write_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR val
)
467 void *pval
= (void *) (uintptr_t) val
;
468 return write_inferior_memory (symaddr
,
469 (unsigned char *) &pval
, sizeof (pval
));
473 write_inferior_integer (CORE_ADDR symaddr
, int val
)
475 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
479 write_inferior_uinteger (CORE_ADDR symaddr
, unsigned int val
)
481 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
484 static CORE_ADDR
target_malloc (ULONGEST size
);
485 static int write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
);
487 #define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
489 memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
490 BUF += sizeof ((OBJ)->FIELD); \
495 /* Operations on various types of tracepoint actions. */
497 struct tracepoint_action
;
499 struct tracepoint_action_ops
501 /* Download tracepoint action ACTION to IPA. Return the address of action
503 CORE_ADDR (*download
) (const struct tracepoint_action
*action
);
505 /* Send ACTION to agent via command buffer started from BUFFER. Return
506 updated head of command buffer. */
507 char* (*send
) (char *buffer
, const struct tracepoint_action
*action
);
510 /* Base action. Concrete actions inherit this. */
512 struct tracepoint_action
514 #ifndef IN_PROCESS_AGENT
515 const struct tracepoint_action_ops
*ops
;
520 /* An 'M' (collect memory) action. */
521 struct collect_memory_action
523 struct tracepoint_action base
;
530 /* An 'R' (collect registers) action. */
532 struct collect_registers_action
534 struct tracepoint_action base
;
537 /* An 'X' (evaluate expression) action. */
539 struct eval_expr_action
541 struct tracepoint_action base
;
543 struct agent_expr
*expr
;
546 /* An 'L' (collect static trace data) action. */
547 struct collect_static_trace_data_action
549 struct tracepoint_action base
;
552 #ifndef IN_PROCESS_AGENT
554 m_tracepoint_action_download (const struct tracepoint_action
*action
)
556 int size_in_ipa
= (sizeof (struct collect_memory_action
)
557 - offsetof (struct tracepoint_action
, type
));
558 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
560 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
566 m_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
568 struct collect_memory_action
*maction
569 = (struct collect_memory_action
*) action
;
571 COPY_FIELD_TO_BUF (buffer
, maction
, addr
);
572 COPY_FIELD_TO_BUF (buffer
, maction
, len
);
573 COPY_FIELD_TO_BUF (buffer
, maction
, basereg
);
578 static const struct tracepoint_action_ops m_tracepoint_action_ops
=
580 m_tracepoint_action_download
,
581 m_tracepoint_action_send
,
585 r_tracepoint_action_download (const struct tracepoint_action
*action
)
587 int size_in_ipa
= (sizeof (struct collect_registers_action
)
588 - offsetof (struct tracepoint_action
, type
));
589 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
591 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
598 r_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
603 static const struct tracepoint_action_ops r_tracepoint_action_ops
=
605 r_tracepoint_action_download
,
606 r_tracepoint_action_send
,
609 static CORE_ADDR
download_agent_expr (struct agent_expr
*expr
);
612 x_tracepoint_action_download (const struct tracepoint_action
*action
)
614 int size_in_ipa
= (sizeof (struct eval_expr_action
)
615 - offsetof (struct tracepoint_action
, type
));
616 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
619 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
621 expr
= download_agent_expr (((struct eval_expr_action
*)action
)->expr
);
622 write_inferior_data_ptr (ipa_action
+ offsetof (struct eval_expr_action
, expr
)
623 - offsetof (struct tracepoint_action
, type
),
629 /* Copy agent expression AEXPR to buffer pointed by P. If AEXPR is NULL,
630 copy 0 to P. Return updated header of buffer. */
633 agent_expr_send (char *p
, const struct agent_expr
*aexpr
)
635 /* Copy the length of condition first, and then copy its
644 memcpy (p
, &aexpr
->length
, 4);
647 memcpy (p
, aexpr
->bytes
, aexpr
->length
);
654 x_tracepoint_action_send ( char *buffer
, const struct tracepoint_action
*action
)
656 struct eval_expr_action
*eaction
= (struct eval_expr_action
*) action
;
658 return agent_expr_send (buffer
, eaction
->expr
);
661 static const struct tracepoint_action_ops x_tracepoint_action_ops
=
663 x_tracepoint_action_download
,
664 x_tracepoint_action_send
,
668 l_tracepoint_action_download (const struct tracepoint_action
*action
)
670 int size_in_ipa
= (sizeof (struct collect_static_trace_data_action
)
671 - offsetof (struct tracepoint_action
, type
));
672 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
674 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
681 l_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
686 static const struct tracepoint_action_ops l_tracepoint_action_ops
=
688 l_tracepoint_action_download
,
689 l_tracepoint_action_send
,
693 /* This structure describes a piece of the source-level definition of
694 the tracepoint. The contents are not interpreted by the target,
695 but preserved verbatim for uploading upon reconnection. */
699 /* The type of string, such as "cond" for a conditional. */
702 /* The source-level string itself. For the sake of target
703 debugging, we store it in plaintext, even though it is always
704 transmitted in hex. */
707 /* Link to the next one in the list. We link them in the order
708 received, in case some make up an ordered list of commands or
710 struct source_string
*next
;
715 /* Trap based tracepoint. */
718 /* A fast tracepoint implemented with a jump instead of a trap. */
721 /* A static tracepoint, implemented by a program call into a tracing
726 struct tracepoint_hit_ctx
;
728 typedef enum eval_result_type (*condfn
) (struct tracepoint_hit_ctx
*,
731 /* The definition of a tracepoint. */
733 /* Tracepoints may have multiple locations, each at a different
734 address. This can occur with optimizations, template
735 instantiation, etc. Since the locations may be in different
736 scopes, the conditions and actions may be different for each
737 location. Our target version of tracepoints is more like GDB's
738 notion of "breakpoint locations", but we have almost nothing that
739 is not per-location, so we bother having two kinds of objects. The
740 key consequence is that numbers are not unique, and that it takes
741 both number and address to identify a tracepoint uniquely. */
745 /* The number of the tracepoint, as specified by GDB. Several
746 tracepoint objects here may share a number. */
749 /* Address at which the tracepoint is supposed to trigger. Several
750 tracepoints may share an address. */
753 /* Tracepoint type. */
754 enum tracepoint_type type
;
756 /* True if the tracepoint is currently enabled. */
759 /* The number of single steps that will be performed after each
763 /* The number of times the tracepoint may be hit before it will
764 terminate the entire tracing run. */
767 /* Pointer to the agent expression that is the tracepoint's
768 conditional, or NULL if the tracepoint is unconditional. */
769 struct agent_expr
*cond
;
771 /* The list of actions to take when the tracepoint triggers. */
773 struct tracepoint_action
**actions
;
775 /* Count of the times we've hit this tracepoint during the run.
776 Note that while-stepping steps are not counted as "hits". */
779 /* Cached sum of the sizes of traceframes created by this point. */
780 uint64_t traceframe_usage
;
782 CORE_ADDR compiled_cond
;
784 /* Link to the next tracepoint in the list. */
785 struct tracepoint
*next
;
787 #ifndef IN_PROCESS_AGENT
788 /* The list of actions to take when the tracepoint triggers, in
789 string/packet form. */
792 /* The collection of strings that describe the tracepoint as it was
793 entered into GDB. These are not used by the target, but are
794 reported back to GDB upon reconnection. */
795 struct source_string
*source_strings
;
797 /* The number of bytes displaced by fast tracepoints. It may subsume
798 multiple instructions, for multi-byte fast tracepoints. This
799 field is only valid for fast tracepoints. */
802 /* Only for fast tracepoints. */
803 CORE_ADDR obj_addr_on_target
;
805 /* Address range where the original instruction under a fast
806 tracepoint was relocated to. (_end is actually one byte past
808 CORE_ADDR adjusted_insn_addr
;
809 CORE_ADDR adjusted_insn_addr_end
;
811 /* The address range of the piece of the jump pad buffer that was
812 assigned to this fast tracepoint. (_end is actually one byte
815 CORE_ADDR jump_pad_end
;
817 /* The address range of the piece of the trampoline buffer that was
818 assigned to this fast tracepoint. (_end is actually one byte
820 CORE_ADDR trampoline
;
821 CORE_ADDR trampoline_end
;
823 /* The list of actions to take while in a stepping loop. These
824 fields are only valid for patch-based tracepoints. */
825 int num_step_actions
;
826 struct tracepoint_action
**step_actions
;
827 /* Same, but in string/packet form. */
828 char **step_actions_str
;
830 /* Handle returned by the breakpoint or tracepoint module when we
831 inserted the trap or jump, or hooked into a static tracepoint.
832 NULL if we haven't inserted it yet. */
838 #ifndef IN_PROCESS_AGENT
840 /* Given `while-stepping', a thread may be collecting data for more
841 than one tracepoint simultaneously. On the other hand, the same
842 tracepoint with a while-stepping action may be hit by more than one
843 thread simultaneously (but not quite, each thread could be handling
844 a different step). Each thread holds a list of these objects,
845 representing the current step of each while-stepping action being
850 struct wstep_state
*next
;
852 /* The tracepoint number. */
854 /* The tracepoint's address. */
855 CORE_ADDR tp_address
;
857 /* The number of the current step in this 'while-stepping'
864 /* The linked list of all tracepoints. Marked explicitly as used as
865 the in-process library doesn't use it for the fast tracepoints
867 IP_AGENT_EXPORT
struct tracepoint
*tracepoints ATTR_USED
;
869 #ifndef IN_PROCESS_AGENT
871 /* Pointer to the last tracepoint in the list, new tracepoints are
872 linked in at the end. */
874 static struct tracepoint
*last_tracepoint
;
877 /* The first tracepoint to exceed its pass count. */
879 IP_AGENT_EXPORT
struct tracepoint
*stopping_tracepoint
;
881 /* True if the trace buffer is full or otherwise no longer usable. */
883 IP_AGENT_EXPORT
int trace_buffer_is_full
;
885 static enum eval_result_type expr_eval_result
= expr_eval_no_error
;
887 #ifndef IN_PROCESS_AGENT
889 static const char *eval_result_names
[] =
891 "terror:in the attic", /* this should never be reported */
892 "terror:empty expression",
893 "terror:empty stack",
894 "terror:stack overflow",
895 "terror:stack underflow",
896 "terror:unhandled opcode",
897 "terror:unrecognized opcode",
898 "terror:divide by zero"
903 /* The tracepoint in which the error occurred. */
905 static struct tracepoint
*error_tracepoint
;
907 struct trace_state_variable
909 /* This is the name of the variable as used in GDB. The target
910 doesn't use the name, but needs to have it for saving and
911 reconnection purposes. */
914 /* This number identifies the variable uniquely. Numbers may be
915 assigned either by the target (in the case of builtin variables),
916 or by GDB, and are presumed unique during the course of a trace
920 /* The variable's initial value, a 64-bit signed integer always. */
921 LONGEST initial_value
;
923 /* The variable's value, a 64-bit signed integer always. */
926 /* Pointer to a getter function, used to supply computed values. */
927 LONGEST (*getter
) (void);
929 /* Link to the next variable. */
930 struct trace_state_variable
*next
;
933 /* Linked list of all trace state variables. */
935 #ifdef IN_PROCESS_AGENT
936 struct trace_state_variable
*alloced_trace_state_variables
;
939 IP_AGENT_EXPORT
struct trace_state_variable
*trace_state_variables
;
941 /* The results of tracing go into a fixed-size space known as the
942 "trace buffer". Because usage follows a limited number of
943 patterns, we manage it ourselves rather than with malloc. Basic
944 rules are that we create only one trace frame at a time, each is
945 variable in size, they are never moved once created, and we only
946 discard if we are doing a circular buffer, and then only the oldest
947 ones. Each trace frame includes its own size, so we don't need to
948 link them together, and the trace frame number is relative to the
949 first one, so we don't need to record numbers. A trace frame also
950 records the number of the tracepoint that created it. The data
951 itself is a series of blocks, each introduced by a single character
952 and with a defined format. Each type of block has enough
953 type/length info to allow scanners to jump quickly from one block
954 to the next without reading each byte in the block. */
956 /* Trace buffer management would be simple - advance a free pointer
957 from beginning to end, then stop - were it not for the circular
958 buffer option, which is a useful way to prevent a trace run from
959 stopping prematurely because the buffer filled up. In the circular
960 case, the location of the first trace frame (trace_buffer_start)
961 moves as old trace frames are discarded. Also, since we grow trace
962 frames incrementally as actions are performed, we wrap around to
963 the beginning of the trace buffer. This is per-block, so each
964 block within a trace frame remains contiguous. Things get messy
965 when the wrapped-around trace frame is the one being discarded; the
966 free space ends up in two parts at opposite ends of the buffer. */
969 # if defined(__GNUC__)
970 # define ATTR_PACKED __attribute__ ((packed))
972 # define ATTR_PACKED /* nothing */
976 /* The data collected at a tracepoint hit. This object should be as
977 small as possible, since there may be a great many of them. We do
978 not need to keep a frame number, because they are all sequential
979 and there are no deletions; so the Nth frame in the buffer is
980 always frame number N. */
984 /* Number of the tracepoint that collected this traceframe. A value
985 of 0 indicates the current end of the trace buffer. We make this
986 a 16-bit field because it's never going to happen that GDB's
987 numbering of tracepoints reaches 32,000. */
990 /* The size of the data in this trace frame. We limit this to 32
991 bits, even on a 64-bit target, because it's just implausible that
992 one is validly going to collect 4 gigabytes of data at a single
994 unsigned int data_size
: 32;
996 /* The base of the trace data, which is contiguous from this point. */
997 unsigned char data
[0];
1001 /* The size of the EOB marker, in bytes. A traceframe with zeroed
1002 fields (and no data) marks the end of trace data. */
1003 #define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
1005 /* The traceframe to be used as the source of data to send back to
1006 GDB. A value of -1 means to get data from the live program. */
1008 int current_traceframe
= -1;
1010 /* This flag is true if the trace buffer is circular, meaning that
1011 when it fills, the oldest trace frames are discarded in order to
1014 #ifndef IN_PROCESS_AGENT
1015 static int circular_trace_buffer
;
1018 /* Size of the trace buffer. */
1020 static LONGEST trace_buffer_size
;
1022 /* Pointer to the block of memory that traceframes all go into. */
1024 static unsigned char *trace_buffer_lo
;
1026 /* Pointer to the end of the trace buffer, more precisely to the byte
1027 after the end of the buffer. */
1029 static unsigned char *trace_buffer_hi
;
1031 /* Control structure holding the read/write/etc. pointers into the
1032 trace buffer. We need more than one of these to implement a
1033 transaction-like mechanism to garantees that both GDBserver and the
1034 in-process agent can try to change the trace buffer
1037 struct trace_buffer_control
1039 /* Pointer to the first trace frame in the buffer. In the
1040 non-circular case, this is equal to trace_buffer_lo, otherwise it
1041 moves around in the buffer. */
1042 unsigned char *start
;
1044 /* Pointer to the free part of the trace buffer. Note that we clear
1045 several bytes at and after this pointer, so that traceframe
1046 scans/searches terminate properly. */
1047 unsigned char *free
;
1049 /* Pointer to the byte after the end of the free part. Note that
1050 this may be smaller than trace_buffer_free in the circular case,
1051 and means that the free part is in two pieces. Initially it is
1052 equal to trace_buffer_hi, then is generally equivalent to
1053 trace_buffer_start. */
1054 unsigned char *end_free
;
1056 /* Pointer to the wraparound. If not equal to trace_buffer_hi, then
1057 this is the point at which the trace data breaks, and resumes at
1059 unsigned char *wrap
;
1062 /* Same as above, to be used by GDBserver when updating the in-process
1064 struct ipa_trace_buffer_control
1073 /* We have possibly both GDBserver and an inferior thread accessing
1074 the same IPA trace buffer memory. The IPA is the producer (tries
1075 to put new frames in the buffer), while GDBserver occasionally
1076 consumes them, that is, flushes the IPA's buffer into its own
1077 buffer. Both sides need to update the trace buffer control
1078 pointers (current head, tail, etc.). We can't use a global lock to
1079 synchronize the accesses, as otherwise we could deadlock GDBserver
1080 (if the thread holding the lock stops for a signal, say). So
1081 instead of that, we use a transaction scheme where GDBserver writes
1082 always prevail over the IPAs writes, and, we have the IPA detect
1083 the commit failure/overwrite, and retry the whole attempt. This is
1084 mainly implemented by having a global token object that represents
1085 who wrote last to the buffer control structure. We need to freeze
1086 any inferior writing to the buffer while GDBserver touches memory,
1087 so that the inferior can correctly detect that GDBserver had been
1088 there, otherwise, it could mistakingly think its commit was
1089 successful; that's implemented by simply having GDBserver set a
1090 breakpoint the inferior hits if it is the critical region.
1092 There are three cycling trace buffer control structure copies
1093 (buffer head, tail, etc.), with the token object including an index
1094 indicating which is current live copy. The IPA tentatively builds
1095 an updated copy in a non-current control structure, while GDBserver
1096 always clobbers the current version directly. The IPA then tries
1097 to atomically "commit" its version; if GDBserver clobbered the
1098 structure meanwhile, that will fail, and the IPA restarts the
1101 Listing the step in further detail, we have:
1103 In-process agent (producer):
1105 - passes by `about_to_request_buffer_space' breakpoint/lock
1107 - reads current token, extracts current trace buffer control index,
1108 and starts tentatively updating the rightmost one (0->1, 1->2,
1109 2->0). Note that only one inferior thread is executing this code
1110 at any given time, due to an outer lock in the jump pads.
1112 - updates counters, and tries to commit the token.
1114 - passes by second `about_to_request_buffer_space' breakpoint/lock,
1115 leaving the sync region.
1117 - checks if the update was effective.
1119 - if trace buffer was found full, hits flush_trace_buffer
1120 breakpoint, and restarts later afterwards.
1122 GDBserver (consumer):
1124 - sets `about_to_request_buffer_space' breakpoint/lock.
1126 - updates the token unconditionally, using the current buffer
1127 control index, since it knows that the IP agent always writes to
1128 the rightmost, and due to the breakpoint, at most one IP thread
1129 can try to update the trace buffer concurrently to GDBserver, so
1130 there will be no danger of trace buffer control index wrap making
1131 the IPA write to the same index as GDBserver.
1133 - flushes the IP agent's trace buffer completely, and updates the
1134 current trace buffer control structure. GDBserver *always* wins.
1136 - removes the `about_to_request_buffer_space' breakpoint.
1138 The token is stored in the `trace_buffer_ctrl_curr' variable.
1139 Internally, it's bits are defined as:
1141 |-------------+-----+-------------+--------+-------------+--------------|
1142 | Bit offsets | 31 | 30 - 20 | 19 | 18-8 | 7-0 |
1143 |-------------+-----+-------------+--------+-------------+--------------|
1144 | What | GSB | PC (11-bit) | unused | CC (11-bit) | TBCI (8-bit) |
1145 |-------------+-----+-------------+--------+-------------+--------------|
1147 GSB - GDBserver Stamp Bit
1148 PC - Previous Counter
1149 CC - Current Counter
1150 TBCI - Trace Buffer Control Index
1153 An IPA update of `trace_buffer_ctrl_curr' does:
1155 - read CC from the current token, save as PC.
1157 - atomically tries to write PC+1,CC
1159 A GDBserver update of `trace_buffer_ctrl_curr' does:
1161 - reads PC and CC from the current token.
1166 /* These are the bits of `trace_buffer_ctrl_curr' that are reserved
1167 for the counters described below. The cleared bits are used to
1168 hold the index of the items of the `trace_buffer_ctrl' array that
1170 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1172 /* `trace_buffer_ctrl_curr' contains two counters. The `previous'
1173 counter, and the `current' counter. */
1175 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1176 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1178 /* When GDBserver update the IP agent's `trace_buffer_ctrl_curr', it
1179 always stamps this bit as set. */
1180 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1182 #ifdef IN_PROCESS_AGENT
1183 IP_AGENT_EXPORT
struct trace_buffer_control trace_buffer_ctrl
[3];
1184 IP_AGENT_EXPORT
unsigned int trace_buffer_ctrl_curr
;
1186 # define TRACE_BUFFER_CTRL_CURR \
1187 (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1191 /* The GDBserver side agent only needs one instance of this object, as
1192 it doesn't need to sync with itself. Define it as array anyway so
1193 that the rest of the code base doesn't need to care for the
1195 struct trace_buffer_control trace_buffer_ctrl
[1];
1196 # define TRACE_BUFFER_CTRL_CURR 0
1199 /* These are convenience macros used to access the current trace
1200 buffer control in effect. */
1201 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1202 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1203 #define trace_buffer_end_free \
1204 (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1205 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1208 /* Macro that returns a pointer to the first traceframe in the buffer. */
1210 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1212 /* Macro that returns a pointer to the next traceframe in the buffer.
1213 If the computed location is beyond the wraparound point, subtract
1214 the offset of the wraparound. */
1216 #define NEXT_TRACEFRAME_1(TF) \
1217 (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1219 #define NEXT_TRACEFRAME(TF) \
1220 ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1221 - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1222 ? (trace_buffer_wrap - trace_buffer_lo) \
1225 /* The difference between these counters represents the total number
1226 of complete traceframes present in the trace buffer. The IP agent
1227 writes to the write count, GDBserver writes to read count. */
1229 IP_AGENT_EXPORT
unsigned int traceframe_write_count
;
1230 IP_AGENT_EXPORT
unsigned int traceframe_read_count
;
1232 /* Convenience macro. */
1234 #define traceframe_count \
1235 ((unsigned int) (traceframe_write_count - traceframe_read_count))
1237 /* The count of all traceframes created in the current run, including
1238 ones that were discarded to make room. */
1240 IP_AGENT_EXPORT
int traceframes_created
;
1242 #ifndef IN_PROCESS_AGENT
1244 /* Read-only regions are address ranges whose contents don't change,
1245 and so can be read from target memory even while looking at a trace
1246 frame. Without these, disassembly for instance will likely fail,
1247 because the program code is not usually collected into a trace
1248 frame. This data structure does not need to be very complicated or
1249 particularly efficient, it's only going to be used occasionally,
1250 and only by some commands. */
1252 struct readonly_region
1254 /* The bounds of the region. */
1255 CORE_ADDR start
, end
;
1257 /* Link to the next one. */
1258 struct readonly_region
*next
;
1261 /* Linked list of readonly regions. This list stays in effect from
1262 one tstart to the next. */
1264 static struct readonly_region
*readonly_regions
;
1268 /* The global that controls tracing overall. */
1270 IP_AGENT_EXPORT
int tracing
;
1272 #ifndef IN_PROCESS_AGENT
1274 /* Controls whether tracing should continue after GDB disconnects. */
1276 int disconnected_tracing
;
1278 /* The reason for the last tracing run to have stopped. We initialize
1279 to a distinct string so that GDB can distinguish between "stopped
1280 after running" and "stopped because never run" cases. */
1282 static const char *tracing_stop_reason
= "tnotrun";
1284 static int tracing_stop_tpnum
;
1286 /* 64-bit timestamps for the trace run's start and finish, expressed
1287 in microseconds from the Unix epoch. */
1289 LONGEST tracing_start_time
;
1290 LONGEST tracing_stop_time
;
1292 /* The (optional) user-supplied name of the user that started the run.
1293 This is an arbitrary string, and may be NULL. */
1295 char *tracing_user_name
;
1297 /* Optional user-supplied text describing the run. This is
1298 an arbitrary string, and may be NULL. */
1300 char *tracing_notes
;
1302 /* Optional user-supplied text explaining a tstop command. This is an
1303 arbitrary string, and may be NULL. */
1305 char *tracing_stop_note
;
1309 /* Functions local to this file. */
1311 /* Base "class" for tracepoint type specific data to be passed down to
1312 collect_data_at_tracepoint. */
1313 struct tracepoint_hit_ctx
1315 enum tracepoint_type type
;
1318 #ifdef IN_PROCESS_AGENT
1320 /* Fast/jump tracepoint specific data to be passed down to
1321 collect_data_at_tracepoint. */
1322 struct fast_tracepoint_ctx
1324 struct tracepoint_hit_ctx base
;
1326 struct regcache regcache
;
1327 int regcache_initted
;
1328 unsigned char *regspace
;
1330 unsigned char *regs
;
1331 struct tracepoint
*tpoint
;
1334 /* Static tracepoint specific data to be passed down to
1335 collect_data_at_tracepoint. */
1336 struct static_tracepoint_ctx
1338 struct tracepoint_hit_ctx base
;
1340 /* The regcache corresponding to the registers state at the time of
1341 the tracepoint hit. Initialized lazily, from REGS. */
1342 struct regcache regcache
;
1343 int regcache_initted
;
1345 /* The buffer space REGCACHE above uses. We use a separate buffer
1346 instead of letting the regcache malloc for both signal safety and
1347 performance reasons; this is allocated on the stack instead. */
1348 unsigned char *regspace
;
1350 /* The register buffer as passed on by lttng/ust. */
1351 struct registers
*regs
;
1353 /* The "printf" formatter and the args the user passed to the marker
1354 call. We use this to be able to collect "static trace data"
1359 /* The GDB tracepoint matching the probed marker that was "hit". */
1360 struct tracepoint
*tpoint
;
1365 /* Static tracepoint specific data to be passed down to
1366 collect_data_at_tracepoint. */
1367 struct trap_tracepoint_ctx
1369 struct tracepoint_hit_ctx base
;
1371 struct regcache
*regcache
;
1376 #ifndef IN_PROCESS_AGENT
1377 static CORE_ADDR
traceframe_get_pc (struct traceframe
*tframe
);
1378 static int traceframe_read_tsv (int num
, LONGEST
*val
);
1381 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1382 struct tracepoint
*tpoint
);
1384 #ifndef IN_PROCESS_AGENT
1385 static void clear_readonly_regions (void);
1386 static void clear_installed_tracepoints (void);
1389 static void collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1391 struct tracepoint
*tpoint
);
1392 #ifndef IN_PROCESS_AGENT
1393 static void collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
1395 struct tracepoint
*tpoint
, int current_step
);
1396 static void compile_tracepoint_condition (struct tracepoint
*tpoint
,
1397 CORE_ADDR
*jump_entry
);
1399 static void do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1401 struct tracepoint
*tpoint
,
1402 struct traceframe
*tframe
,
1403 struct tracepoint_action
*taction
);
1405 #ifndef IN_PROCESS_AGENT
1406 static struct tracepoint
*fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR
);
1408 static void install_tracepoint (struct tracepoint
*, char *own_buf
);
1409 static void download_tracepoint (struct tracepoint
*);
1410 static int install_fast_tracepoint (struct tracepoint
*, char *errbuf
);
1411 static void clone_fast_tracepoint (struct tracepoint
*to
,
1412 const struct tracepoint
*from
);
1415 static LONGEST
get_timestamp (void);
1417 #if defined(__GNUC__)
1418 # define memory_barrier() asm volatile ("" : : : "memory")
1420 # define memory_barrier() do {} while (0)
1423 /* We only build the IPA if this builtin is supported, and there are
1424 no uses of this in GDBserver itself, so we're safe in defining this
1426 #define cmpxchg(mem, oldval, newval) \
1427 __sync_val_compare_and_swap (mem, oldval, newval)
1429 /* Record that an error occurred during expression evaluation. */
1432 record_tracepoint_error (struct tracepoint
*tpoint
, const char *which
,
1433 enum eval_result_type rtype
)
1435 trace_debug ("Tracepoint %d at %s %s eval reports error %d",
1436 tpoint
->number
, paddress (tpoint
->address
), which
, rtype
);
1438 #ifdef IN_PROCESS_AGENT
1439 /* Only record the first error we get. */
1440 if (cmpxchg (&expr_eval_result
,
1442 rtype
) != expr_eval_no_error
)
1445 if (expr_eval_result
!= expr_eval_no_error
)
1449 error_tracepoint
= tpoint
;
1452 /* Trace buffer management. */
1455 clear_trace_buffer (void)
1457 trace_buffer_start
= trace_buffer_lo
;
1458 trace_buffer_free
= trace_buffer_lo
;
1459 trace_buffer_end_free
= trace_buffer_hi
;
1460 trace_buffer_wrap
= trace_buffer_hi
;
1461 /* A traceframe with zeroed fields marks the end of trace data. */
1462 ((struct traceframe
*) trace_buffer_free
)->tpnum
= 0;
1463 ((struct traceframe
*) trace_buffer_free
)->data_size
= 0;
1464 traceframe_read_count
= traceframe_write_count
= 0;
1465 traceframes_created
= 0;
1468 #ifndef IN_PROCESS_AGENT
1471 clear_inferior_trace_buffer (void)
1473 CORE_ADDR ipa_trace_buffer_lo
;
1474 CORE_ADDR ipa_trace_buffer_hi
;
1475 struct traceframe ipa_traceframe
= { 0 };
1476 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
1478 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
1479 &ipa_trace_buffer_lo
);
1480 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
1481 &ipa_trace_buffer_hi
);
1483 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
1484 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
1485 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
1486 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
1488 /* A traceframe with zeroed fields marks the end of trace data. */
1489 write_inferior_memory (ipa_sym_addrs
.addr_trace_buffer_ctrl
,
1490 (unsigned char *) &ipa_trace_buffer_ctrl
,
1491 sizeof (ipa_trace_buffer_ctrl
));
1493 write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
, 0);
1495 /* A traceframe with zeroed fields marks the end of trace data. */
1496 write_inferior_memory (ipa_trace_buffer_lo
,
1497 (unsigned char *) &ipa_traceframe
,
1498 sizeof (ipa_traceframe
));
1500 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
, 0);
1501 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
, 0);
1502 write_inferior_integer (ipa_sym_addrs
.addr_traceframes_created
, 0);
1508 init_trace_buffer (LONGEST bufsize
)
1512 trace_buffer_size
= bufsize
;
1514 /* Make sure to internally allocate at least space for the EOB
1516 alloc_size
= (bufsize
< TRACEFRAME_EOB_MARKER_SIZE
1517 ? TRACEFRAME_EOB_MARKER_SIZE
: bufsize
);
1518 trace_buffer_lo
= xrealloc (trace_buffer_lo
, alloc_size
);
1520 trace_buffer_hi
= trace_buffer_lo
+ trace_buffer_size
;
1522 clear_trace_buffer ();
1525 #ifdef IN_PROCESS_AGENT
1527 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
1528 about_to_request_buffer_space (void)
1530 /* GDBserver places breakpoint here while it goes about to flush
1531 data at random times. */
1532 UNKNOWN_SIDE_EFFECTS();
1537 /* Carve out a piece of the trace buffer, returning NULL in case of
1541 trace_buffer_alloc (size_t amt
)
1543 unsigned char *rslt
;
1544 struct trace_buffer_control
*tbctrl
;
1546 #ifdef IN_PROCESS_AGENT
1547 unsigned int prev
, prev_filtered
;
1548 unsigned int commit_count
;
1549 unsigned int commit
;
1550 unsigned int readout
;
1552 struct traceframe
*oldest
;
1553 unsigned char *new_start
;
1556 trace_debug ("Want to allocate %ld+%ld bytes in trace buffer",
1557 (long) amt
, (long) sizeof (struct traceframe
));
1559 /* Account for the EOB marker. */
1560 amt
+= TRACEFRAME_EOB_MARKER_SIZE
;
1562 #ifdef IN_PROCESS_AGENT
1566 /* Read the current token and extract the index to try to write to,
1567 storing it in CURR. */
1568 prev
= trace_buffer_ctrl_curr
;
1569 prev_filtered
= prev
& ~GDBSERVER_FLUSH_COUNT_MASK
;
1570 curr
= prev_filtered
+ 1;
1574 about_to_request_buffer_space ();
1576 /* Start out with a copy of the current state. GDBserver may be
1577 midway writing to the PREV_FILTERED TBC, but, that's OK, we won't
1578 be able to commit anyway if that happens. */
1579 trace_buffer_ctrl
[curr
]
1580 = trace_buffer_ctrl
[prev_filtered
];
1581 trace_debug ("trying curr=%u", curr
);
1583 /* The GDBserver's agent doesn't need all that syncing, and always
1584 updates TCB 0 (there's only one, mind you). */
1587 tbctrl
= &trace_buffer_ctrl
[curr
];
1589 /* Offsets are easier to grok for debugging than raw addresses,
1590 especially for the small trace buffer sizes that are useful for
1592 trace_debug ("Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1594 (int) (tbctrl
->start
- trace_buffer_lo
),
1595 (int) (tbctrl
->free
- trace_buffer_lo
),
1596 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1597 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1598 (int) (trace_buffer_hi
- trace_buffer_lo
));
1600 /* The algorithm here is to keep trying to get a contiguous block of
1601 the requested size, possibly discarding older traceframes to free
1602 up space. Since free space might come in one or two pieces,
1603 depending on whether discarded traceframes wrapped around at the
1604 high end of the buffer, we test both pieces after each
1608 /* First, if we have two free parts, try the upper one first. */
1609 if (tbctrl
->end_free
< tbctrl
->free
)
1611 if (tbctrl
->free
+ amt
<= trace_buffer_hi
)
1612 /* We have enough in the upper part. */
1616 /* Our high part of free space wasn't enough. Give up
1617 on it for now, set wraparound. We will recover the
1618 space later, if/when the wrapped-around traceframe is
1620 trace_debug ("Upper part too small, setting wraparound");
1621 tbctrl
->wrap
= tbctrl
->free
;
1622 tbctrl
->free
= trace_buffer_lo
;
1626 /* The normal case. */
1627 if (tbctrl
->free
+ amt
<= tbctrl
->end_free
)
1630 #ifdef IN_PROCESS_AGENT
1631 /* The IP Agent's buffer is always circular. It isn't used
1632 currently, but `circular_trace_buffer' could represent
1633 GDBserver's mode. If we didn't find space, ask GDBserver to
1636 flush_trace_buffer ();
1640 trace_debug ("gdbserver flushed buffer, retrying");
1644 /* GDBserver cancelled the tracing. Bail out as well. */
1647 /* If we're here, then neither part is big enough, and
1648 non-circular trace buffers are now full. */
1649 if (!circular_trace_buffer
)
1651 trace_debug ("Not enough space in the trace buffer");
1655 trace_debug ("Need more space in the trace buffer");
1657 /* If we have a circular buffer, we can try discarding the
1658 oldest traceframe and see if that helps. */
1659 oldest
= FIRST_TRACEFRAME ();
1660 if (oldest
->tpnum
== 0)
1662 /* Not good; we have no traceframes to free. Perhaps we're
1663 asking for a block that is larger than the buffer? In
1664 any case, give up. */
1665 trace_debug ("No traceframes to discard");
1669 /* We don't run this code in the in-process agent currently.
1670 E.g., we could leave the in-process agent in autonomous
1671 circular mode if we only have fast tracepoints. If we do
1672 that, then this bit becomes racy with GDBserver, which also
1673 writes to this counter. */
1674 --traceframe_write_count
;
1676 new_start
= (unsigned char *) NEXT_TRACEFRAME (oldest
);
1677 /* If we freed the traceframe that wrapped around, go back
1678 to the non-wrap case. */
1679 if (new_start
< tbctrl
->start
)
1681 trace_debug ("Discarding past the wraparound");
1682 tbctrl
->wrap
= trace_buffer_hi
;
1684 tbctrl
->start
= new_start
;
1685 tbctrl
->end_free
= tbctrl
->start
;
1687 trace_debug ("Discarded a traceframe\n"
1688 "Trace buffer [%d], start=%d free=%d "
1689 "endfree=%d wrap=%d hi=%d",
1691 (int) (tbctrl
->start
- trace_buffer_lo
),
1692 (int) (tbctrl
->free
- trace_buffer_lo
),
1693 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1694 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1695 (int) (trace_buffer_hi
- trace_buffer_lo
));
1697 /* Now go back around the loop. The discard might have resulted
1698 in either one or two pieces of free space, so we want to try
1699 both before freeing any more traceframes. */
1703 /* If we get here, we know we can provide the asked-for space. */
1705 rslt
= tbctrl
->free
;
1707 /* Adjust the request back down, now that we know we have space for
1708 the marker, but don't commit to AMT yet, we may still need to
1709 restart the operation if GDBserver touches the trace buffer
1710 (obviously only important in the in-process agent's version). */
1711 tbctrl
->free
+= (amt
- sizeof (struct traceframe
));
1713 /* Or not. If GDBserver changed the trace buffer behind our back,
1714 we get to restart a new allocation attempt. */
1716 #ifdef IN_PROCESS_AGENT
1717 /* Build the tentative token. */
1718 commit_count
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) + 0x100)
1719 & GDBSERVER_FLUSH_COUNT_MASK_CURR
);
1720 commit
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) << 12)
1724 /* Try to commit it. */
1725 readout
= cmpxchg (&trace_buffer_ctrl_curr
, prev
, commit
);
1726 if (readout
!= prev
)
1728 trace_debug ("GDBserver has touched the trace buffer, restarting."
1729 " (prev=%08x, commit=%08x, readout=%08x)",
1730 prev
, commit
, readout
);
1734 /* Hold your horses here. Even if that change was committed,
1735 GDBserver could come in, and clobber it. We need to hold to be
1736 able to tell if GDBserver clobbers before or after we committed
1737 the change. Whenever GDBserver goes about touching the IPA
1738 buffer, it sets a breakpoint in this routine, so we have a sync
1740 about_to_request_buffer_space ();
1742 /* Check if the change has been effective, even if GDBserver stopped
1743 us at the breakpoint. */
1746 unsigned int refetch
;
1750 refetch
= trace_buffer_ctrl_curr
;
1752 if (refetch
== commit
1753 || ((refetch
& GDBSERVER_FLUSH_COUNT_MASK_PREV
) >> 12) == commit_count
)
1756 trace_debug ("change is effective: (prev=%08x, commit=%08x, "
1757 "readout=%08x, refetch=%08x)",
1758 prev
, commit
, readout
, refetch
);
1762 trace_debug ("GDBserver has touched the trace buffer, not effective."
1763 " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1764 prev
, commit
, readout
, refetch
);
1770 /* We have a new piece of the trace buffer. Hurray! */
1772 /* Add an EOB marker just past this allocation. */
1773 ((struct traceframe
*) tbctrl
->free
)->tpnum
= 0;
1774 ((struct traceframe
*) tbctrl
->free
)->data_size
= 0;
1776 /* Adjust the request back down, now that we know we have space for
1778 amt
-= sizeof (struct traceframe
);
1782 trace_debug ("Allocated %d bytes", (int) amt
);
1783 trace_debug ("Trace buffer [%d] start=%d free=%d "
1784 "endfree=%d wrap=%d hi=%d",
1786 (int) (tbctrl
->start
- trace_buffer_lo
),
1787 (int) (tbctrl
->free
- trace_buffer_lo
),
1788 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1789 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1790 (int) (trace_buffer_hi
- trace_buffer_lo
));
1796 #ifndef IN_PROCESS_AGENT
1798 /* Return the total free space. This is not necessarily the largest
1799 block we can allocate, because of the two-part case. */
1804 if (trace_buffer_free
<= trace_buffer_end_free
)
1805 return trace_buffer_end_free
- trace_buffer_free
;
1807 return ((trace_buffer_end_free
- trace_buffer_lo
)
1808 + (trace_buffer_hi
- trace_buffer_free
));
1811 /* An 'S' in continuation packets indicates remainder are for
1814 static int seen_step_action_flag
;
1816 /* Create a tracepoint (location) with given number and address. Add this
1817 new tracepoint to list and sort this list. */
1819 static struct tracepoint
*
1820 add_tracepoint (int num
, CORE_ADDR addr
)
1822 struct tracepoint
*tpoint
, **tp_next
;
1824 tpoint
= xmalloc (sizeof (struct tracepoint
));
1825 tpoint
->number
= num
;
1826 tpoint
->address
= addr
;
1827 tpoint
->numactions
= 0;
1828 tpoint
->actions
= NULL
;
1829 tpoint
->actions_str
= NULL
;
1830 tpoint
->cond
= NULL
;
1831 tpoint
->num_step_actions
= 0;
1832 tpoint
->step_actions
= NULL
;
1833 tpoint
->step_actions_str
= NULL
;
1834 /* Start all off as regular (slow) tracepoints. */
1835 tpoint
->type
= trap_tracepoint
;
1836 tpoint
->orig_size
= -1;
1837 tpoint
->source_strings
= NULL
;
1838 tpoint
->compiled_cond
= 0;
1839 tpoint
->handle
= NULL
;
1840 tpoint
->next
= NULL
;
1842 /* Find a place to insert this tracepoint into list in order to keep
1843 the tracepoint list still in the ascending order. There may be
1844 multiple tracepoints at the same address as TPOINT's, and this
1845 guarantees TPOINT is inserted after all the tracepoints which are
1846 set at the same address. For example, fast tracepoints A, B, C are
1847 set at the same address, and D is to be insert at the same place as
1850 -->| A |--> | B |-->| C |->...
1852 One jump pad was created for tracepoint A, B, and C, and the target
1853 address of A is referenced/used in jump pad. So jump pad will let
1854 inferior jump to A. If D is inserted in front of A, like this,
1856 -->| D |-->| A |--> | B |-->| C |->...
1858 without updating jump pad, D is not reachable during collect, which
1859 is wrong. As we can see, the order of B, C and D doesn't matter, but
1860 A should always be the `first' one. */
1861 for (tp_next
= &tracepoints
;
1862 (*tp_next
) != NULL
&& (*tp_next
)->address
<= tpoint
->address
;
1863 tp_next
= &(*tp_next
)->next
)
1865 tpoint
->next
= *tp_next
;
1867 last_tracepoint
= tpoint
;
1869 seen_step_action_flag
= 0;
1874 #ifndef IN_PROCESS_AGENT
1876 /* Return the tracepoint with the given number and address, or NULL. */
1878 static struct tracepoint
*
1879 find_tracepoint (int id
, CORE_ADDR addr
)
1881 struct tracepoint
*tpoint
;
1883 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
1884 if (tpoint
->number
== id
&& tpoint
->address
== addr
)
1890 /* Remove TPOINT from global list. */
1893 remove_tracepoint (struct tracepoint
*tpoint
)
1895 struct tracepoint
*tp
, *tp_prev
;
1897 for (tp
= tracepoints
, tp_prev
= NULL
; tp
&& tp
!= tpoint
;
1898 tp_prev
= tp
, tp
= tp
->next
)
1904 tp_prev
->next
= tp
->next
;
1906 tracepoints
= tp
->next
;
1912 /* There may be several tracepoints with the same number (because they
1913 are "locations", in GDB parlance); return the next one after the
1914 given tracepoint, or search from the beginning of the list if the
1915 first argument is NULL. */
1917 static struct tracepoint
*
1918 find_next_tracepoint_by_number (struct tracepoint
*prev_tp
, int num
)
1920 struct tracepoint
*tpoint
;
1923 tpoint
= prev_tp
->next
;
1925 tpoint
= tracepoints
;
1926 for (; tpoint
; tpoint
= tpoint
->next
)
1927 if (tpoint
->number
== num
)
1935 /* Append another action to perform when the tracepoint triggers. */
1938 add_tracepoint_action (struct tracepoint
*tpoint
, char *packet
)
1944 seen_step_action_flag
= 1;
1952 char *act_start
= act
;
1953 struct tracepoint_action
*action
= NULL
;
1959 struct collect_memory_action
*maction
;
1963 maction
= xmalloc (sizeof *maction
);
1964 maction
->base
.type
= *act
;
1965 maction
->base
.ops
= &m_tracepoint_action_ops
;
1966 action
= &maction
->base
;
1969 is_neg
= (*act
== '-');
1972 act
= unpack_varlen_hex (act
, &basereg
);
1974 act
= unpack_varlen_hex (act
, &maction
->addr
);
1976 act
= unpack_varlen_hex (act
, &maction
->len
);
1977 maction
->basereg
= (is_neg
1980 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
1981 pulongest (maction
->len
),
1982 paddress (maction
->addr
), maction
->basereg
);
1987 struct collect_registers_action
*raction
;
1989 raction
= xmalloc (sizeof *raction
);
1990 raction
->base
.type
= *act
;
1991 raction
->base
.ops
= &r_tracepoint_action_ops
;
1992 action
= &raction
->base
;
1994 trace_debug ("Want to collect registers");
1996 /* skip past hex digits of mask for now */
1997 while (isxdigit(*act
))
2003 struct collect_static_trace_data_action
*raction
;
2005 raction
= xmalloc (sizeof *raction
);
2006 raction
->base
.type
= *act
;
2007 raction
->base
.ops
= &l_tracepoint_action_ops
;
2008 action
= &raction
->base
;
2010 trace_debug ("Want to collect static trace data");
2015 trace_debug ("Unexpected step action, ignoring");
2020 struct eval_expr_action
*xaction
;
2022 xaction
= xmalloc (sizeof (*xaction
));
2023 xaction
->base
.type
= *act
;
2024 xaction
->base
.ops
= &x_tracepoint_action_ops
;
2025 action
= &xaction
->base
;
2027 trace_debug ("Want to evaluate expression");
2028 xaction
->expr
= gdb_parse_agent_expr (&act
);
2032 trace_debug ("unknown trace action '%c', ignoring...", *act
);
2041 if (seen_step_action_flag
)
2043 tpoint
->num_step_actions
++;
2045 tpoint
->step_actions
2046 = xrealloc (tpoint
->step_actions
,
2047 (sizeof (*tpoint
->step_actions
)
2048 * tpoint
->num_step_actions
));
2049 tpoint
->step_actions_str
2050 = xrealloc (tpoint
->step_actions_str
,
2051 (sizeof (*tpoint
->step_actions_str
)
2052 * tpoint
->num_step_actions
));
2053 tpoint
->step_actions
[tpoint
->num_step_actions
- 1] = action
;
2054 tpoint
->step_actions_str
[tpoint
->num_step_actions
- 1]
2055 = savestring (act_start
, act
- act_start
);
2059 tpoint
->numactions
++;
2061 = xrealloc (tpoint
->actions
,
2062 sizeof (*tpoint
->actions
) * tpoint
->numactions
);
2064 = xrealloc (tpoint
->actions_str
,
2065 sizeof (*tpoint
->actions_str
) * tpoint
->numactions
);
2066 tpoint
->actions
[tpoint
->numactions
- 1] = action
;
2067 tpoint
->actions_str
[tpoint
->numactions
- 1]
2068 = savestring (act_start
, act
- act_start
);
2075 /* Find or create a trace state variable with the given number. */
2077 static struct trace_state_variable
*
2078 get_trace_state_variable (int num
)
2080 struct trace_state_variable
*tsv
;
2082 #ifdef IN_PROCESS_AGENT
2083 /* Search for an existing variable. */
2084 for (tsv
= alloced_trace_state_variables
; tsv
; tsv
= tsv
->next
)
2085 if (tsv
->number
== num
)
2089 /* Search for an existing variable. */
2090 for (tsv
= trace_state_variables
; tsv
; tsv
= tsv
->next
)
2091 if (tsv
->number
== num
)
2097 /* Find or create a trace state variable with the given number. */
2099 static struct trace_state_variable
*
2100 create_trace_state_variable (int num
, int gdb
)
2102 struct trace_state_variable
*tsv
;
2104 tsv
= get_trace_state_variable (num
);
2108 /* Create a new variable. */
2109 tsv
= xmalloc (sizeof (struct trace_state_variable
));
2111 tsv
->initial_value
= 0;
2115 #ifdef IN_PROCESS_AGENT
2118 tsv
->next
= alloced_trace_state_variables
;
2119 alloced_trace_state_variables
= tsv
;
2124 tsv
->next
= trace_state_variables
;
2125 trace_state_variables
= tsv
;
2130 IP_AGENT_EXPORT LONGEST
2131 get_trace_state_variable_value (int num
)
2133 struct trace_state_variable
*tsv
;
2135 tsv
= get_trace_state_variable (num
);
2139 trace_debug ("No trace state variable %d, skipping value get", num
);
2143 /* Call a getter function if we have one. While it's tempting to
2144 set up something to only call the getter once per tracepoint hit,
2145 it could run afoul of thread races. Better to let the getter
2146 handle it directly, if necessary to worry about it. */
2148 tsv
->value
= (tsv
->getter
) ();
2150 trace_debug ("get_trace_state_variable_value(%d) ==> %s",
2151 num
, plongest (tsv
->value
));
2156 IP_AGENT_EXPORT
void
2157 set_trace_state_variable_value (int num
, LONGEST val
)
2159 struct trace_state_variable
*tsv
;
2161 tsv
= get_trace_state_variable (num
);
2165 trace_debug ("No trace state variable %d, skipping value set", num
);
2173 agent_get_trace_state_variable_value (int num
)
2175 return get_trace_state_variable_value (num
);
2179 agent_set_trace_state_variable_value (int num
, LONGEST val
)
2181 set_trace_state_variable_value (num
, val
);
2185 set_trace_state_variable_name (int num
, const char *name
)
2187 struct trace_state_variable
*tsv
;
2189 tsv
= get_trace_state_variable (num
);
2193 trace_debug ("No trace state variable %d, skipping name set", num
);
2197 tsv
->name
= (char *) name
;
2201 set_trace_state_variable_getter (int num
, LONGEST (*getter
) (void))
2203 struct trace_state_variable
*tsv
;
2205 tsv
= get_trace_state_variable (num
);
2209 trace_debug ("No trace state variable %d, skipping getter set", num
);
2213 tsv
->getter
= getter
;
2216 /* Add a raw traceframe for the given tracepoint. */
2218 static struct traceframe
*
2219 add_traceframe (struct tracepoint
*tpoint
)
2221 struct traceframe
*tframe
;
2223 tframe
= trace_buffer_alloc (sizeof (struct traceframe
));
2228 tframe
->tpnum
= tpoint
->number
;
2229 tframe
->data_size
= 0;
2234 /* Add a block to the traceframe currently being worked on. */
2236 static unsigned char *
2237 add_traceframe_block (struct traceframe
*tframe
,
2238 struct tracepoint
*tpoint
, int amt
)
2240 unsigned char *block
;
2245 block
= trace_buffer_alloc (amt
);
2250 gdb_assert (tframe
->tpnum
== tpoint
->number
);
2252 tframe
->data_size
+= amt
;
2253 tpoint
->traceframe_usage
+= amt
;
2258 /* Flag that the current traceframe is finished. */
2261 finish_traceframe (struct traceframe
*tframe
)
2263 ++traceframe_write_count
;
2264 ++traceframes_created
;
2267 #ifndef IN_PROCESS_AGENT
2269 /* Given a traceframe number NUM, find the NUMth traceframe in the
2272 static struct traceframe
*
2273 find_traceframe (int num
)
2275 struct traceframe
*tframe
;
2278 for (tframe
= FIRST_TRACEFRAME ();
2280 tframe
= NEXT_TRACEFRAME (tframe
))
2291 get_traceframe_address (struct traceframe
*tframe
)
2294 struct tracepoint
*tpoint
;
2296 addr
= traceframe_get_pc (tframe
);
2301 /* Fallback strategy, will be incorrect for while-stepping frames
2302 and multi-location tracepoints. */
2303 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
2304 return tpoint
->address
;
2307 /* Search for the next traceframe whose address is inside or outside
2310 static struct traceframe
*
2311 find_next_traceframe_in_range (CORE_ADDR lo
, CORE_ADDR hi
, int inside_p
,
2314 struct traceframe
*tframe
;
2317 *tfnump
= current_traceframe
+ 1;
2318 tframe
= find_traceframe (*tfnump
);
2319 /* The search is not supposed to wrap around. */
2326 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2328 tfaddr
= get_traceframe_address (tframe
);
2330 ? (lo
<= tfaddr
&& tfaddr
<= hi
)
2331 : (lo
> tfaddr
|| tfaddr
> hi
))
2340 /* Search for the next traceframe recorded by the given tracepoint.
2341 Note that for multi-location tracepoints, this will find whatever
2342 location appears first. */
2344 static struct traceframe
*
2345 find_next_traceframe_by_tracepoint (int num
, int *tfnump
)
2347 struct traceframe
*tframe
;
2349 *tfnump
= current_traceframe
+ 1;
2350 tframe
= find_traceframe (*tfnump
);
2351 /* The search is not supposed to wrap around. */
2358 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2360 if (tframe
->tpnum
== num
)
2371 #ifndef IN_PROCESS_AGENT
2373 /* Clear all past trace state. */
2376 cmd_qtinit (char *packet
)
2378 struct trace_state_variable
*tsv
, *prev
, *next
;
2380 /* Make sure we don't try to read from a trace frame. */
2381 current_traceframe
= -1;
2385 trace_debug ("Initializing the trace");
2387 clear_installed_tracepoints ();
2388 clear_readonly_regions ();
2391 last_tracepoint
= NULL
;
2393 /* Clear out any leftover trace state variables. Ones with target
2394 defined getters should be kept however. */
2396 tsv
= trace_state_variables
;
2399 trace_debug ("Looking at var %d", tsv
->number
);
2400 if (tsv
->getter
== NULL
)
2406 trace_state_variables
= next
;
2407 trace_debug ("Deleting var %d", tsv
->number
);
2418 clear_trace_buffer ();
2419 clear_inferior_trace_buffer ();
2424 /* Unprobe the UST marker at ADDRESS. */
2427 unprobe_marker_at (CORE_ADDR address
)
2429 char cmd
[IPA_CMD_BUF_SIZE
];
2431 sprintf (cmd
, "unprobe_marker_at:%s", paddress (address
));
2432 run_inferior_command (cmd
, strlen (cmd
) + 1);
2435 /* Restore the program to its pre-tracing state. This routine may be called
2436 in error situations, so it needs to be careful about only restoring
2437 from known-valid bits. */
2440 clear_installed_tracepoints (void)
2442 struct tracepoint
*tpoint
;
2443 struct tracepoint
*prev_stpoint
;
2446 cancel_breakpoints ();
2448 prev_stpoint
= NULL
;
2450 /* Restore any bytes overwritten by tracepoints. */
2451 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
2453 /* Catch the case where we might try to remove a tracepoint that
2454 was never actually installed. */
2455 if (tpoint
->handle
== NULL
)
2457 trace_debug ("Tracepoint %d at 0x%s was "
2458 "never installed, nothing to clear",
2459 tpoint
->number
, paddress (tpoint
->address
));
2463 switch (tpoint
->type
)
2465 case trap_tracepoint
:
2466 delete_breakpoint (tpoint
->handle
);
2468 case fast_tracepoint
:
2469 delete_fast_tracepoint_jump (tpoint
->handle
);
2471 case static_tracepoint
:
2472 if (prev_stpoint
!= NULL
2473 && prev_stpoint
->address
== tpoint
->address
)
2474 /* Nothing to do. We already unprobed a tracepoint set at
2475 this marker address (and there can only be one probe
2480 unprobe_marker_at (tpoint
->address
);
2481 prev_stpoint
= tpoint
;
2486 tpoint
->handle
= NULL
;
2492 /* Parse a packet that defines a tracepoint. */
2495 cmd_qtdp (char *own_buf
)
2498 /* Whether there is a trailing hyphen at the end of the QTDP packet. */
2499 int trail_hyphen
= 0;
2503 struct tracepoint
*tpoint
;
2505 char *packet
= own_buf
;
2507 packet
+= strlen ("QTDP:");
2509 /* A hyphen at the beginning marks a packet specifying actions for a
2510 tracepoint already supplied. */
2517 packet
= unpack_varlen_hex (packet
, &num
);
2518 ++packet
; /* skip a colon */
2519 packet
= unpack_varlen_hex (packet
, &addr
);
2520 ++packet
; /* skip a colon */
2522 /* See if we already have this tracepoint. */
2523 tpoint
= find_tracepoint (num
, addr
);
2527 /* Duplicate tracepoints are never allowed. */
2530 trace_debug ("Tracepoint error: tracepoint %d"
2531 " at 0x%s already exists",
2532 (int) num
, paddress (addr
));
2533 write_enn (own_buf
);
2537 tpoint
= add_tracepoint (num
, addr
);
2539 tpoint
->enabled
= (*packet
== 'E');
2540 ++packet
; /* skip 'E' */
2541 ++packet
; /* skip a colon */
2542 packet
= unpack_varlen_hex (packet
, &count
);
2543 tpoint
->step_count
= count
;
2544 ++packet
; /* skip a colon */
2545 packet
= unpack_varlen_hex (packet
, &count
);
2546 tpoint
->pass_count
= count
;
2547 /* See if we have any of the additional optional fields. */
2548 while (*packet
== ':')
2553 tpoint
->type
= fast_tracepoint
;
2555 packet
= unpack_varlen_hex (packet
, &count
);
2556 tpoint
->orig_size
= count
;
2558 else if (*packet
== 'S')
2560 tpoint
->type
= static_tracepoint
;
2563 else if (*packet
== 'X')
2565 actparm
= (char *) packet
;
2566 tpoint
->cond
= gdb_parse_agent_expr (&actparm
);
2569 else if (*packet
== '-')
2571 else if (*packet
== '\0')
2574 trace_debug ("Unknown optional tracepoint field");
2579 trace_debug ("Also has actions\n");
2582 trace_debug ("Defined %stracepoint %d at 0x%s, "
2583 "enabled %d step %" PRIu64
" pass %" PRIu64
,
2584 tpoint
->type
== fast_tracepoint
? "fast "
2585 : tpoint
->type
== static_tracepoint
? "static " : "",
2586 tpoint
->number
, paddress (tpoint
->address
), tpoint
->enabled
,
2587 tpoint
->step_count
, tpoint
->pass_count
);
2590 add_tracepoint_action (tpoint
, packet
);
2593 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2594 (int) num
, paddress (addr
));
2595 write_enn (own_buf
);
2599 /* Install tracepoint during tracing only once for each tracepoint location.
2600 For each tracepoint loc, GDB may send multiple QTDP packets, and we can
2601 determine the last QTDP packet for one tracepoint location by checking
2602 trailing hyphen in QTDP packet. */
2603 if (tracing
&& !trail_hyphen
)
2605 struct tracepoint
*tp
= NULL
;
2607 /* Pause all threads temporarily while we patch tracepoints. */
2610 /* download_tracepoint will update global `tracepoints'
2611 list, so it is unsafe to leave threads in jump pad. */
2612 stabilize_threads ();
2614 /* Freeze threads. */
2618 if (tpoint
->type
!= trap_tracepoint
)
2620 /* Find another fast or static tracepoint at the same address. */
2621 for (tp
= tracepoints
; tp
; tp
= tp
->next
)
2623 if (tp
->address
== tpoint
->address
&& tp
->type
== tpoint
->type
2624 && tp
->number
!= tpoint
->number
)
2628 /* TPOINT is installed at the same address as TP. */
2631 if (tpoint
->type
== fast_tracepoint
)
2632 clone_fast_tracepoint (tpoint
, tp
);
2633 else if (tpoint
->type
== static_tracepoint
)
2634 tpoint
->handle
= (void *) -1;
2638 if (use_agent
&& tpoint
->type
== fast_tracepoint
2639 && agent_capability_check (AGENT_CAPA_FAST_TRACE
))
2641 /* Download and install fast tracepoint by agent. */
2642 if (tracepoint_send_agent (tpoint
) == 0)
2646 write_enn (own_buf
);
2647 remove_tracepoint (tpoint
);
2652 download_tracepoint (tpoint
);
2654 if (tpoint
->type
== trap_tracepoint
|| tp
== NULL
)
2656 install_tracepoint (tpoint
, own_buf
);
2657 if (strcmp (own_buf
, "OK") != 0)
2658 remove_tracepoint (tpoint
);
2672 cmd_qtdpsrc (char *own_buf
)
2674 ULONGEST num
, addr
, start
, slen
;
2675 struct tracepoint
*tpoint
;
2676 char *packet
= own_buf
;
2677 char *saved
, *srctype
, *src
;
2679 struct source_string
*last
, *newlast
;
2681 packet
+= strlen ("QTDPsrc:");
2683 packet
= unpack_varlen_hex (packet
, &num
);
2684 ++packet
; /* skip a colon */
2685 packet
= unpack_varlen_hex (packet
, &addr
);
2686 ++packet
; /* skip a colon */
2688 /* See if we already have this tracepoint. */
2689 tpoint
= find_tracepoint (num
, addr
);
2693 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2694 (int) num
, paddress (addr
));
2695 write_enn (own_buf
);
2700 packet
= strchr (packet
, ':');
2701 srctype
= xmalloc (packet
- saved
+ 1);
2702 memcpy (srctype
, saved
, packet
- saved
);
2703 srctype
[packet
- saved
] = '\0';
2705 packet
= unpack_varlen_hex (packet
, &start
);
2706 ++packet
; /* skip a colon */
2707 packet
= unpack_varlen_hex (packet
, &slen
);
2708 ++packet
; /* skip a colon */
2709 src
= xmalloc (slen
+ 1);
2710 nbytes
= hex2bin (packet
, (gdb_byte
*) src
, strlen (packet
) / 2);
2713 newlast
= xmalloc (sizeof (struct source_string
));
2714 newlast
->type
= srctype
;
2716 newlast
->next
= NULL
;
2717 /* Always add a source string to the end of the list;
2718 this keeps sequences of actions/commands in the right
2720 if (tpoint
->source_strings
)
2722 for (last
= tpoint
->source_strings
; last
->next
; last
= last
->next
)
2724 last
->next
= newlast
;
2727 tpoint
->source_strings
= newlast
;
2733 cmd_qtdv (char *own_buf
)
2735 ULONGEST num
, val
, builtin
;
2738 struct trace_state_variable
*tsv
;
2739 char *packet
= own_buf
;
2741 packet
+= strlen ("QTDV:");
2743 packet
= unpack_varlen_hex (packet
, &num
);
2744 ++packet
; /* skip a colon */
2745 packet
= unpack_varlen_hex (packet
, &val
);
2746 ++packet
; /* skip a colon */
2747 packet
= unpack_varlen_hex (packet
, &builtin
);
2748 ++packet
; /* skip a colon */
2750 nbytes
= strlen (packet
) / 2;
2751 varname
= xmalloc (nbytes
+ 1);
2752 nbytes
= hex2bin (packet
, (gdb_byte
*) varname
, nbytes
);
2753 varname
[nbytes
] = '\0';
2755 tsv
= create_trace_state_variable (num
, 1);
2756 tsv
->initial_value
= (LONGEST
) val
;
2757 tsv
->name
= varname
;
2759 set_trace_state_variable_value (num
, (LONGEST
) val
);
2765 cmd_qtenable_disable (char *own_buf
, int enable
)
2767 char *packet
= own_buf
;
2769 struct tracepoint
*tp
;
2771 packet
+= strlen (enable
? "QTEnable:" : "QTDisable:");
2772 packet
= unpack_varlen_hex (packet
, &num
);
2773 ++packet
; /* skip a colon */
2774 packet
= unpack_varlen_hex (packet
, &addr
);
2776 tp
= find_tracepoint (num
, addr
);
2780 if ((enable
&& tp
->enabled
) || (!enable
&& !tp
->enabled
))
2782 trace_debug ("Tracepoint %d at 0x%s is already %s",
2783 (int) num
, paddress (addr
),
2784 enable
? "enabled" : "disabled");
2789 trace_debug ("%s tracepoint %d at 0x%s",
2790 enable
? "Enabling" : "Disabling",
2791 (int) num
, paddress (addr
));
2793 tp
->enabled
= enable
;
2795 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
2798 int offset
= offsetof (struct tracepoint
, enabled
);
2799 CORE_ADDR obj_addr
= tp
->obj_addr_on_target
+ offset
;
2801 ret
= prepare_to_access_memory ();
2804 trace_debug ("Failed to temporarily stop inferior threads");
2805 write_enn (own_buf
);
2809 ret
= write_inferior_integer (obj_addr
, enable
);
2810 done_accessing_memory ();
2814 trace_debug ("Cannot write enabled flag into "
2815 "inferior process memory");
2816 write_enn (own_buf
);
2825 trace_debug ("Tracepoint %d at 0x%s not found",
2826 (int) num
, paddress (addr
));
2827 write_enn (own_buf
);
2832 cmd_qtv (char *own_buf
)
2837 char *packet
= own_buf
;
2839 packet
+= strlen ("qTV:");
2840 unpack_varlen_hex (packet
, &num
);
2842 if (current_traceframe
>= 0)
2844 err
= traceframe_read_tsv ((int) num
, &val
);
2847 strcpy (own_buf
, "U");
2851 /* Only make tsv's be undefined before the first trace run. After a
2852 trace run is over, the user might want to see the last value of
2853 the tsv, and it might not be available in a traceframe. */
2854 else if (!tracing
&& strcmp (tracing_stop_reason
, "tnotrun") == 0)
2856 strcpy (own_buf
, "U");
2860 val
= get_trace_state_variable_value (num
);
2862 sprintf (own_buf
, "V%s", phex_nz (val
, 0));
2865 /* Clear out the list of readonly regions. */
2868 clear_readonly_regions (void)
2870 struct readonly_region
*roreg
;
2872 while (readonly_regions
)
2874 roreg
= readonly_regions
;
2875 readonly_regions
= readonly_regions
->next
;
2880 /* Parse the collection of address ranges whose contents GDB believes
2881 to be unchanging and so can be read directly from target memory
2882 even while looking at a traceframe. */
2885 cmd_qtro (char *own_buf
)
2887 ULONGEST start
, end
;
2888 struct readonly_region
*roreg
;
2889 char *packet
= own_buf
;
2891 trace_debug ("Want to mark readonly regions");
2893 clear_readonly_regions ();
2895 packet
+= strlen ("QTro");
2897 while (*packet
== ':')
2899 ++packet
; /* skip a colon */
2900 packet
= unpack_varlen_hex (packet
, &start
);
2901 ++packet
; /* skip a comma */
2902 packet
= unpack_varlen_hex (packet
, &end
);
2903 roreg
= xmalloc (sizeof (struct readonly_region
));
2904 roreg
->start
= start
;
2906 roreg
->next
= readonly_regions
;
2907 readonly_regions
= roreg
;
2908 trace_debug ("Added readonly region from 0x%s to 0x%s",
2909 paddress (roreg
->start
), paddress (roreg
->end
));
2915 /* Test to see if the given range is in our list of readonly ranges.
2916 We only test for being entirely within a range, GDB is not going to
2917 send a single memory packet that spans multiple regions. */
2920 in_readonly_region (CORE_ADDR addr
, ULONGEST length
)
2922 struct readonly_region
*roreg
;
2924 for (roreg
= readonly_regions
; roreg
; roreg
= roreg
->next
)
2925 if (roreg
->start
<= addr
&& (addr
+ length
- 1) <= roreg
->end
)
2931 /* The maximum size of a jump pad entry. */
2932 static const int max_jump_pad_size
= 0x100;
2934 static CORE_ADDR gdb_jump_pad_head
;
2936 /* Return the address of the next free jump space. */
2939 get_jump_space_head (void)
2941 if (gdb_jump_pad_head
== 0)
2943 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
2944 &gdb_jump_pad_head
))
2946 internal_error (__FILE__
, __LINE__
,
2947 "error extracting jump_pad_buffer");
2951 return gdb_jump_pad_head
;
2954 /* Reserve USED bytes from the jump space. */
2957 claim_jump_space (ULONGEST used
)
2959 trace_debug ("claim_jump_space reserves %s bytes at %s",
2960 pulongest (used
), paddress (gdb_jump_pad_head
));
2961 gdb_jump_pad_head
+= used
;
2964 static CORE_ADDR trampoline_buffer_head
= 0;
2965 static CORE_ADDR trampoline_buffer_tail
;
2967 /* Reserve USED bytes from the trampoline buffer and return the
2968 address of the start of the reserved space in TRAMPOLINE. Returns
2969 non-zero if the space is successfully claimed. */
2972 claim_trampoline_space (ULONGEST used
, CORE_ADDR
*trampoline
)
2974 if (!trampoline_buffer_head
)
2976 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
2977 &trampoline_buffer_tail
))
2979 internal_error (__FILE__
, __LINE__
,
2980 "error extracting trampoline_buffer");
2983 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
2984 &trampoline_buffer_head
))
2986 internal_error (__FILE__
, __LINE__
,
2987 "error extracting trampoline_buffer_end");
2991 /* Start claiming space from the top of the trampoline space. If
2992 the space is located at the bottom of the virtual address space,
2993 this reduces the possibility that corruption will occur if a null
2994 pointer is used to write to memory. */
2995 if (trampoline_buffer_head
- trampoline_buffer_tail
< used
)
2997 trace_debug ("claim_trampoline_space failed to reserve %s bytes",
3002 trampoline_buffer_head
-= used
;
3004 trace_debug ("claim_trampoline_space reserves %s bytes at %s",
3005 pulongest (used
), paddress (trampoline_buffer_head
));
3007 *trampoline
= trampoline_buffer_head
;
3011 /* Returns non-zero if there is space allocated for use in trampolines
3012 for fast tracepoints. */
3015 have_fast_tracepoint_trampoline_buffer (char *buf
)
3017 CORE_ADDR trampoline_end
, errbuf
;
3019 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
3022 internal_error (__FILE__
, __LINE__
,
3023 "error extracting trampoline_buffer_end");
3029 strcpy (buf
, "was claiming");
3030 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_error
,
3033 internal_error (__FILE__
, __LINE__
,
3034 "error extracting errbuf");
3037 read_inferior_memory (errbuf
, (unsigned char *) buf
, 100);
3040 return trampoline_end
!= 0;
3043 /* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
3044 the command fails, or 0 otherwise. If the command ran
3045 successfully, but probing the marker failed, ERROUT will be filled
3046 with the error to reply to GDB, and -1 is also returned. This
3047 allows directly passing IPA errors to GDB. */
3050 probe_marker_at (CORE_ADDR address
, char *errout
)
3052 char cmd
[IPA_CMD_BUF_SIZE
];
3055 sprintf (cmd
, "probe_marker_at:%s", paddress (address
));
3056 err
= run_inferior_command (cmd
, strlen (cmd
) + 1);
3062 strcpy (errout
, cmd
);
3071 clone_fast_tracepoint (struct tracepoint
*to
, const struct tracepoint
*from
)
3073 to
->jump_pad
= from
->jump_pad
;
3074 to
->jump_pad_end
= from
->jump_pad_end
;
3075 to
->trampoline
= from
->trampoline
;
3076 to
->trampoline_end
= from
->trampoline_end
;
3077 to
->adjusted_insn_addr
= from
->adjusted_insn_addr
;
3078 to
->adjusted_insn_addr_end
= from
->adjusted_insn_addr_end
;
3079 to
->handle
= from
->handle
;
3081 gdb_assert (from
->handle
);
3082 inc_ref_fast_tracepoint_jump ((struct fast_tracepoint_jump
*) from
->handle
);
3085 #define MAX_JUMP_SIZE 20
3087 /* Install fast tracepoint. Return 0 if successful, otherwise return
3091 install_fast_tracepoint (struct tracepoint
*tpoint
, char *errbuf
)
3093 CORE_ADDR jentry
, jump_entry
;
3094 CORE_ADDR trampoline
;
3095 ULONGEST trampoline_size
;
3097 /* The jump to the jump pad of the last fast tracepoint
3099 unsigned char fjump
[MAX_JUMP_SIZE
];
3100 ULONGEST fjump_size
;
3102 if (tpoint
->orig_size
< target_get_min_fast_tracepoint_insn_len ())
3104 trace_debug ("Requested a fast tracepoint on an instruction "
3105 "that is of less than the minimum length.");
3109 jentry
= jump_entry
= get_jump_space_head ();
3112 trampoline_size
= 0;
3114 /* Install the jump pad. */
3115 err
= install_fast_tracepoint_jump_pad (tpoint
->obj_addr_on_target
,
3117 ipa_sym_addrs
.addr_gdb_collect
,
3118 ipa_sym_addrs
.addr_collecting
,
3121 &trampoline
, &trampoline_size
,
3123 &tpoint
->adjusted_insn_addr
,
3124 &tpoint
->adjusted_insn_addr_end
,
3131 tpoint
->handle
= set_fast_tracepoint_jump (tpoint
->address
, fjump
,
3134 if (tpoint
->handle
!= NULL
)
3136 tpoint
->jump_pad
= jump_entry
;
3137 tpoint
->jump_pad_end
= jentry
;
3138 tpoint
->trampoline
= trampoline
;
3139 tpoint
->trampoline_end
= trampoline
+ trampoline_size
;
3141 /* Pad to 8-byte alignment. */
3142 jentry
= ((jentry
+ 7) & ~0x7);
3143 claim_jump_space (jentry
- jump_entry
);
3150 /* Install tracepoint TPOINT, and write reply message in OWN_BUF. */
3153 install_tracepoint (struct tracepoint
*tpoint
, char *own_buf
)
3155 tpoint
->handle
= NULL
;
3158 if (tpoint
->type
== trap_tracepoint
)
3160 /* Tracepoints are installed as memory breakpoints. Just go
3161 ahead and install the trap. The breakpoints module
3162 handles duplicated breakpoints, and the memory read
3163 routine handles un-patching traps from memory reads. */
3164 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3165 tracepoint_handler
);
3167 else if (tpoint
->type
== fast_tracepoint
|| tpoint
->type
== static_tracepoint
)
3169 if (!agent_loaded_p ())
3171 trace_debug ("Requested a %s tracepoint, but fast "
3172 "tracepoints aren't supported.",
3173 tpoint
->type
== static_tracepoint
? "static" : "fast");
3174 write_e_ipa_not_loaded (own_buf
);
3177 if (tpoint
->type
== static_tracepoint
3178 && !in_process_agent_supports_ust ())
3180 trace_debug ("Requested a static tracepoint, but static "
3181 "tracepoints are not supported.");
3182 write_e_ust_not_loaded (own_buf
);
3186 if (tpoint
->type
== fast_tracepoint
)
3187 install_fast_tracepoint (tpoint
, own_buf
);
3190 if (probe_marker_at (tpoint
->address
, own_buf
) == 0)
3191 tpoint
->handle
= (void *) -1;
3196 internal_error (__FILE__
, __LINE__
, "Unknown tracepoint type");
3198 if (tpoint
->handle
== NULL
)
3200 if (*own_buf
== '\0')
3201 write_enn (own_buf
);
3207 static void download_tracepoint_1 (struct tracepoint
*tpoint
);
3210 cmd_qtstart (char *packet
)
3212 struct tracepoint
*tpoint
, *prev_ftpoint
, *prev_stpoint
;
3213 CORE_ADDR tpptr
= 0, prev_tpptr
= 0;
3215 trace_debug ("Starting the trace");
3217 /* Pause all threads temporarily while we patch tracepoints. */
3220 /* Get threads out of jump pads. Safe to do here, since this is a
3221 top level command. And, required to do here, since we're
3222 deleting/rewriting jump pads. */
3224 stabilize_threads ();
3226 /* Freeze threads. */
3229 /* Sync the fast tracepoints list in the inferior ftlib. */
3230 if (agent_loaded_p ())
3231 download_trace_state_variables ();
3233 /* No previous fast tpoint yet. */
3234 prev_ftpoint
= NULL
;
3236 /* No previous static tpoint yet. */
3237 prev_stpoint
= NULL
;
3241 /* Start out empty. */
3242 if (agent_loaded_p ())
3243 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, 0);
3245 /* Download and install tracepoints. */
3246 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
3248 /* Ensure all the hit counts start at zero. */
3249 tpoint
->hit_count
= 0;
3250 tpoint
->traceframe_usage
= 0;
3252 if (tpoint
->type
== trap_tracepoint
)
3254 /* Tracepoints are installed as memory breakpoints. Just go
3255 ahead and install the trap. The breakpoints module
3256 handles duplicated breakpoints, and the memory read
3257 routine handles un-patching traps from memory reads. */
3258 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3259 tracepoint_handler
);
3261 else if (tpoint
->type
== fast_tracepoint
3262 || tpoint
->type
== static_tracepoint
)
3264 if (maybe_write_ipa_not_loaded (packet
))
3266 trace_debug ("Requested a %s tracepoint, but fast "
3267 "tracepoints aren't supported.",
3268 tpoint
->type
== static_tracepoint
3269 ? "static" : "fast");
3273 if (tpoint
->type
== fast_tracepoint
)
3276 = use_agent
&& agent_capability_check (AGENT_CAPA_FAST_TRACE
);
3278 if (prev_ftpoint
!= NULL
3279 && prev_ftpoint
->address
== tpoint
->address
)
3282 tracepoint_send_agent (tpoint
);
3284 download_tracepoint_1 (tpoint
);
3286 clone_fast_tracepoint (tpoint
, prev_ftpoint
);
3290 /* Tracepoint is installed successfully? */
3293 /* Download and install fast tracepoint by agent. */
3295 installed
= !tracepoint_send_agent (tpoint
);
3298 download_tracepoint_1 (tpoint
);
3299 installed
= !install_fast_tracepoint (tpoint
, packet
);
3303 prev_ftpoint
= tpoint
;
3308 if (!in_process_agent_supports_ust ())
3310 trace_debug ("Requested a static tracepoint, but static "
3311 "tracepoints are not supported.");
3315 download_tracepoint_1 (tpoint
);
3316 /* Can only probe a given marker once. */
3317 if (prev_stpoint
!= NULL
3318 && prev_stpoint
->address
== tpoint
->address
)
3319 tpoint
->handle
= (void *) -1;
3322 if (probe_marker_at (tpoint
->address
, packet
) == 0)
3324 tpoint
->handle
= (void *) -1;
3326 /* So that we can handle multiple static tracepoints
3327 at the same address easily. */
3328 prev_stpoint
= tpoint
;
3334 tpptr
= tpoint
->obj_addr_on_target
;
3336 if (tpoint
== tracepoints
)
3337 /* First object in list, set the head pointer in the
3339 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, tpptr
);
3341 write_inferior_data_ptr (prev_tpptr
+ offsetof (struct tracepoint
,
3346 /* Any failure in the inner loop is sufficient cause to give
3348 if (tpoint
->handle
== NULL
)
3352 /* Any error in tracepoint insertion is unacceptable; better to
3353 address the problem now, than end up with a useless or misleading
3357 clear_installed_tracepoints ();
3358 if (*packet
== '\0')
3364 stopping_tracepoint
= NULL
;
3365 trace_buffer_is_full
= 0;
3366 expr_eval_result
= expr_eval_no_error
;
3367 error_tracepoint
= NULL
;
3368 tracing_start_time
= get_timestamp ();
3370 /* Tracing is now active, hits will now start being logged. */
3373 if (agent_loaded_p ())
3375 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 1))
3377 internal_error (__FILE__
, __LINE__
,
3378 "Error setting tracing variable in lib");
3381 if (write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
3384 internal_error (__FILE__
, __LINE__
,
3385 "Error clearing stopping_tracepoint variable"
3389 if (write_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
, 0))
3391 internal_error (__FILE__
, __LINE__
,
3392 "Error clearing trace_buffer_is_full variable"
3396 stop_tracing_bkpt
= set_breakpoint_at (ipa_sym_addrs
.addr_stop_tracing
,
3397 stop_tracing_handler
);
3398 if (stop_tracing_bkpt
== NULL
)
3399 error ("Error setting stop_tracing breakpoint");
3401 flush_trace_buffer_bkpt
3402 = set_breakpoint_at (ipa_sym_addrs
.addr_flush_trace_buffer
,
3403 flush_trace_buffer_handler
);
3404 if (flush_trace_buffer_bkpt
== NULL
)
3405 error ("Error setting flush_trace_buffer breakpoint");
3413 /* End a tracing run, filling in a stop reason to report back to GDB,
3414 and removing the tracepoints from the code. */
3421 trace_debug ("Tracing is already off, ignoring");
3425 trace_debug ("Stopping the trace");
3427 /* Pause all threads before removing fast jumps from memory,
3428 breakpoints, and touching IPA state variables (inferior memory).
3429 Some thread may hit the internal tracing breakpoints, or be
3430 collecting this moment, but that's ok, we don't release the
3431 tpoint object's memory or the jump pads here (we only do that
3432 when we're sure we can move all threads out of the jump pads).
3433 We can't now, since we may be getting here due to the inferior
3434 agent calling us. */
3436 /* Since we're removing breakpoints, cancel breakpoint hits,
3437 possibly related to the breakpoints we're about to delete. */
3438 cancel_breakpoints ();
3440 /* Stop logging. Tracepoints can still be hit, but they will not be
3443 if (agent_loaded_p ())
3445 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 0))
3447 internal_error (__FILE__
, __LINE__
,
3448 "Error clearing tracing variable in lib");
3452 tracing_stop_time
= get_timestamp ();
3453 tracing_stop_reason
= "t???";
3454 tracing_stop_tpnum
= 0;
3455 if (stopping_tracepoint
)
3457 trace_debug ("Stopping the trace because "
3458 "tracepoint %d was hit %" PRIu64
" times",
3459 stopping_tracepoint
->number
,
3460 stopping_tracepoint
->pass_count
);
3461 tracing_stop_reason
= "tpasscount";
3462 tracing_stop_tpnum
= stopping_tracepoint
->number
;
3464 else if (trace_buffer_is_full
)
3466 trace_debug ("Stopping the trace because the trace buffer is full");
3467 tracing_stop_reason
= "tfull";
3469 else if (expr_eval_result
!= expr_eval_no_error
)
3471 trace_debug ("Stopping the trace because of an expression eval error");
3472 tracing_stop_reason
= eval_result_names
[expr_eval_result
];
3473 tracing_stop_tpnum
= error_tracepoint
->number
;
3475 #ifndef IN_PROCESS_AGENT
3476 else if (!gdb_connected ())
3478 trace_debug ("Stopping the trace because GDB disconnected");
3479 tracing_stop_reason
= "tdisconnected";
3484 trace_debug ("Stopping the trace because of a tstop command");
3485 tracing_stop_reason
= "tstop";
3488 stopping_tracepoint
= NULL
;
3489 error_tracepoint
= NULL
;
3491 /* Clear out the tracepoints. */
3492 clear_installed_tracepoints ();
3494 if (agent_loaded_p ())
3496 /* Pull in fast tracepoint trace frames from the inferior lib
3497 buffer into our buffer, even if our buffer is already full,
3498 because we want to present the full number of created frames
3499 in addition to what fit in the trace buffer. */
3500 upload_fast_traceframes ();
3503 if (stop_tracing_bkpt
!= NULL
)
3505 delete_breakpoint (stop_tracing_bkpt
);
3506 stop_tracing_bkpt
= NULL
;
3509 if (flush_trace_buffer_bkpt
!= NULL
)
3511 delete_breakpoint (flush_trace_buffer_bkpt
);
3512 flush_trace_buffer_bkpt
= NULL
;
3519 stop_tracing_handler (CORE_ADDR addr
)
3521 trace_debug ("lib hit stop_tracing");
3523 /* Don't actually handle it here. When we stop tracing we remove
3524 breakpoints from the inferior, and that is not allowed in a
3525 breakpoint handler (as the caller is walking the breakpoint
3531 flush_trace_buffer_handler (CORE_ADDR addr
)
3533 trace_debug ("lib hit flush_trace_buffer");
3538 cmd_qtstop (char *packet
)
3545 cmd_qtdisconnected (char *own_buf
)
3548 char *packet
= own_buf
;
3550 packet
+= strlen ("QTDisconnected:");
3552 unpack_varlen_hex (packet
, &setting
);
3556 disconnected_tracing
= setting
;
3560 cmd_qtframe (char *own_buf
)
3562 ULONGEST frame
, pc
, lo
, hi
, num
;
3564 struct traceframe
*tframe
;
3565 char *packet
= own_buf
;
3567 packet
+= strlen ("QTFrame:");
3569 if (strncmp (packet
, "pc:", strlen ("pc:")) == 0)
3571 packet
+= strlen ("pc:");
3572 unpack_varlen_hex (packet
, &pc
);
3573 trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc
));
3574 tframe
= find_next_traceframe_in_range (pc
, pc
, 1, &tfnum
);
3576 else if (strncmp (packet
, "range:", strlen ("range:")) == 0)
3578 packet
+= strlen ("range:");
3579 packet
= unpack_varlen_hex (packet
, &lo
);
3581 unpack_varlen_hex (packet
, &hi
);
3582 trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s",
3583 paddress (lo
), paddress (hi
));
3584 tframe
= find_next_traceframe_in_range (lo
, hi
, 1, &tfnum
);
3586 else if (strncmp (packet
, "outside:", strlen ("outside:")) == 0)
3588 packet
+= strlen ("outside:");
3589 packet
= unpack_varlen_hex (packet
, &lo
);
3591 unpack_varlen_hex (packet
, &hi
);
3592 trace_debug ("Want to find next traceframe "
3593 "outside the range 0x%s to 0x%s",
3594 paddress (lo
), paddress (hi
));
3595 tframe
= find_next_traceframe_in_range (lo
, hi
, 0, &tfnum
);
3597 else if (strncmp (packet
, "tdp:", strlen ("tdp:")) == 0)
3599 packet
+= strlen ("tdp:");
3600 unpack_varlen_hex (packet
, &num
);
3602 trace_debug ("Want to find next traceframe for tracepoint %d", tpnum
);
3603 tframe
= find_next_traceframe_by_tracepoint (tpnum
, &tfnum
);
3607 unpack_varlen_hex (packet
, &frame
);
3608 tfnum
= (int) frame
;
3611 trace_debug ("Want to stop looking at traceframes");
3612 current_traceframe
= -1;
3616 trace_debug ("Want to look at traceframe %d", tfnum
);
3617 tframe
= find_traceframe (tfnum
);
3622 current_traceframe
= tfnum
;
3623 sprintf (own_buf
, "F%xT%x", tfnum
, tframe
->tpnum
);
3626 sprintf (own_buf
, "F-1");
3630 cmd_qtstatus (char *packet
)
3632 char *stop_reason_rsp
= NULL
;
3633 char *buf1
, *buf2
, *buf3
, *str
;
3636 /* Translate the plain text of the notes back into hex for
3639 str
= (tracing_user_name
? tracing_user_name
: "");
3640 slen
= strlen (str
);
3641 buf1
= (char *) alloca (slen
* 2 + 1);
3642 bin2hex ((gdb_byte
*) str
, buf1
, slen
);
3644 str
= (tracing_notes
? tracing_notes
: "");
3645 slen
= strlen (str
);
3646 buf2
= (char *) alloca (slen
* 2 + 1);
3647 bin2hex ((gdb_byte
*) str
, buf2
, slen
);
3649 str
= (tracing_stop_note
? tracing_stop_note
: "");
3650 slen
= strlen (str
);
3651 buf3
= (char *) alloca (slen
* 2 + 1);
3652 bin2hex ((gdb_byte
*) str
, buf3
, slen
);
3654 trace_debug ("Returning trace status as %d, stop reason %s",
3655 tracing
, tracing_stop_reason
);
3657 if (agent_loaded_p ())
3661 upload_fast_traceframes ();
3666 stop_reason_rsp
= (char *) tracing_stop_reason
;
3668 /* The user visible error string in terror needs to be hex encoded.
3669 We leave it as plain string in `tracing_stop_reason' to ease
3671 if (strncmp (stop_reason_rsp
, "terror:", strlen ("terror:")) == 0)
3673 const char *result_name
;
3677 result_name
= stop_reason_rsp
+ strlen ("terror:");
3678 hexstr_len
= strlen (result_name
) * 2;
3679 p
= stop_reason_rsp
= alloca (strlen ("terror:") + hexstr_len
+ 1);
3680 strcpy (p
, "terror:");
3682 bin2hex ((gdb_byte
*) result_name
, p
, strlen (result_name
));
3685 /* If this was a forced stop, include any stop note that was supplied. */
3686 if (strcmp (stop_reason_rsp
, "tstop") == 0)
3688 stop_reason_rsp
= alloca (strlen ("tstop:") + strlen (buf3
) + 1);
3689 strcpy (stop_reason_rsp
, "tstop:");
3690 strcat (stop_reason_rsp
, buf3
);
3696 "tframes:%x;tcreated:%x;"
3697 "tfree:%x;tsize:%s;"
3700 "starttime:%s;stoptime:%s;"
3701 "username:%s;notes:%s:",
3703 stop_reason_rsp
, tracing_stop_tpnum
,
3704 traceframe_count
, traceframes_created
,
3705 free_space (), phex_nz (trace_buffer_hi
- trace_buffer_lo
, 0),
3706 circular_trace_buffer
,
3707 disconnected_tracing
,
3708 phex_nz (tracing_start_time
, sizeof (tracing_start_time
)),
3709 phex_nz (tracing_stop_time
, sizeof (tracing_stop_time
)),
3714 cmd_qtp (char *own_buf
)
3717 struct tracepoint
*tpoint
;
3718 char *packet
= own_buf
;
3720 packet
+= strlen ("qTP:");
3722 packet
= unpack_varlen_hex (packet
, &num
);
3723 ++packet
; /* skip a colon */
3724 packet
= unpack_varlen_hex (packet
, &addr
);
3726 /* See if we already have this tracepoint. */
3727 tpoint
= find_tracepoint (num
, addr
);
3731 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
3732 (int) num
, paddress (addr
));
3733 write_enn (own_buf
);
3737 sprintf (own_buf
, "V%" PRIu64
":%" PRIu64
"", tpoint
->hit_count
,
3738 tpoint
->traceframe_usage
);
3741 /* State variables to help return all the tracepoint bits. */
3742 static struct tracepoint
*cur_tpoint
;
3743 static unsigned int cur_action
;
3744 static unsigned int cur_step_action
;
3745 static struct source_string
*cur_source_string
;
3746 static struct trace_state_variable
*cur_tsv
;
3748 /* Compose a response that is an imitation of the syntax by which the
3749 tracepoint was originally downloaded. */
3752 response_tracepoint (char *packet
, struct tracepoint
*tpoint
)
3756 sprintf (packet
, "T%x:%s:%c:%" PRIx64
":%" PRIx64
, tpoint
->number
,
3757 paddress (tpoint
->address
),
3758 (tpoint
->enabled
? 'E' : 'D'), tpoint
->step_count
,
3759 tpoint
->pass_count
);
3760 if (tpoint
->type
== fast_tracepoint
)
3761 sprintf (packet
+ strlen (packet
), ":F%x", tpoint
->orig_size
);
3762 else if (tpoint
->type
== static_tracepoint
)
3763 sprintf (packet
+ strlen (packet
), ":S");
3767 buf
= gdb_unparse_agent_expr (tpoint
->cond
);
3768 sprintf (packet
+ strlen (packet
), ":X%x,%s",
3769 tpoint
->cond
->length
, buf
);
3774 /* Compose a response that is an imitation of the syntax by which the
3775 tracepoint action was originally downloaded (with the difference
3776 that due to the way we store the actions, this will output a packet
3777 per action, while GDB could have combined more than one action
3781 response_action (char *packet
, struct tracepoint
*tpoint
,
3782 char *taction
, int step
)
3784 sprintf (packet
, "%c%x:%s:%s",
3785 (step
? 'S' : 'A'), tpoint
->number
, paddress (tpoint
->address
),
3789 /* Compose a response that is an imitation of the syntax by which the
3790 tracepoint source piece was originally downloaded. */
3793 response_source (char *packet
,
3794 struct tracepoint
*tpoint
, struct source_string
*src
)
3799 len
= strlen (src
->str
);
3800 buf
= alloca (len
* 2 + 1);
3801 bin2hex ((gdb_byte
*) src
->str
, buf
, len
);
3803 sprintf (packet
, "Z%x:%s:%s:%x:%x:%s",
3804 tpoint
->number
, paddress (tpoint
->address
),
3805 src
->type
, 0, len
, buf
);
3808 /* Return the first piece of tracepoint definition, and initialize the
3809 state machine that will iterate through all the tracepoint
3813 cmd_qtfp (char *packet
)
3815 trace_debug ("Returning first tracepoint definition piece");
3817 cur_tpoint
= tracepoints
;
3818 cur_action
= cur_step_action
= 0;
3819 cur_source_string
= NULL
;
3822 response_tracepoint (packet
, cur_tpoint
);
3824 strcpy (packet
, "l");
3827 /* Return additional pieces of tracepoint definition. Each action and
3828 stepping action must go into its own packet, because of packet size
3829 limits, and so we use state variables to deliver one piece at a
3833 cmd_qtsp (char *packet
)
3835 trace_debug ("Returning subsequent tracepoint definition piece");
3839 /* This case would normally never occur, but be prepared for
3841 strcpy (packet
, "l");
3843 else if (cur_action
< cur_tpoint
->numactions
)
3845 response_action (packet
, cur_tpoint
,
3846 cur_tpoint
->actions_str
[cur_action
], 0);
3849 else if (cur_step_action
< cur_tpoint
->num_step_actions
)
3851 response_action (packet
, cur_tpoint
,
3852 cur_tpoint
->step_actions_str
[cur_step_action
], 1);
3855 else if ((cur_source_string
3856 ? cur_source_string
->next
3857 : cur_tpoint
->source_strings
))
3859 if (cur_source_string
)
3860 cur_source_string
= cur_source_string
->next
;
3862 cur_source_string
= cur_tpoint
->source_strings
;
3863 response_source (packet
, cur_tpoint
, cur_source_string
);
3867 cur_tpoint
= cur_tpoint
->next
;
3868 cur_action
= cur_step_action
= 0;
3869 cur_source_string
= NULL
;
3871 response_tracepoint (packet
, cur_tpoint
);
3873 strcpy (packet
, "l");
3877 /* Compose a response that is an imitation of the syntax by which the
3878 trace state variable was originally downloaded. */
3881 response_tsv (char *packet
, struct trace_state_variable
*tsv
)
3883 char *buf
= (char *) "";
3888 namelen
= strlen (tsv
->name
);
3889 buf
= alloca (namelen
* 2 + 1);
3890 bin2hex ((gdb_byte
*) tsv
->name
, buf
, namelen
);
3893 sprintf (packet
, "%x:%s:%x:%s", tsv
->number
, phex_nz (tsv
->initial_value
, 0),
3894 tsv
->getter
? 1 : 0, buf
);
3897 /* Return the first trace state variable definition, and initialize
3898 the state machine that will iterate through all the tsv bits. */
3901 cmd_qtfv (char *packet
)
3903 trace_debug ("Returning first trace state variable definition");
3905 cur_tsv
= trace_state_variables
;
3908 response_tsv (packet
, cur_tsv
);
3910 strcpy (packet
, "l");
3913 /* Return additional trace state variable definitions. */
3916 cmd_qtsv (char *packet
)
3918 trace_debug ("Returning additional trace state variable definition");
3922 cur_tsv
= cur_tsv
->next
;
3924 response_tsv (packet
, cur_tsv
);
3926 strcpy (packet
, "l");
3929 strcpy (packet
, "l");
3932 /* Return the first static tracepoint marker, and initialize the state
3933 machine that will iterate through all the static tracepoints
3937 cmd_qtfstm (char *packet
)
3939 if (!maybe_write_ipa_ust_not_loaded (packet
))
3940 run_inferior_command (packet
, strlen (packet
) + 1);
3943 /* Return additional static tracepoints markers. */
3946 cmd_qtsstm (char *packet
)
3948 if (!maybe_write_ipa_ust_not_loaded (packet
))
3949 run_inferior_command (packet
, strlen (packet
) + 1);
3952 /* Return the definition of the static tracepoint at a given address.
3953 Result packet is the same as qTsST's. */
3956 cmd_qtstmat (char *packet
)
3958 if (!maybe_write_ipa_ust_not_loaded (packet
))
3959 run_inferior_command (packet
, strlen (packet
) + 1);
3962 /* Helper for gdb_agent_about_to_close.
3963 Return non-zero if thread ENTRY is in the same process in DATA. */
3966 same_process_p (struct inferior_list_entry
*entry
, void *data
)
3970 return ptid_get_pid (entry
->id
) == *pid
;
3973 /* Sent the agent a command to close it. */
3976 gdb_agent_about_to_close (int pid
)
3978 char buf
[IPA_CMD_BUF_SIZE
];
3980 if (!maybe_write_ipa_not_loaded (buf
))
3982 struct thread_info
*save_inferior
;
3984 save_inferior
= current_inferior
;
3986 /* Find any thread which belongs to process PID. */
3987 current_inferior
= (struct thread_info
*)
3988 find_inferior (&all_threads
, same_process_p
, &pid
);
3990 strcpy (buf
, "close");
3992 run_inferior_command (buf
, strlen (buf
) + 1);
3994 current_inferior
= save_inferior
;
3998 /* Return the minimum instruction size needed for fast tracepoints as a
3999 hexadecimal number. */
4002 cmd_qtminftpilen (char *packet
)
4004 if (current_inferior
== NULL
)
4006 /* Indicate that the minimum length is currently unknown. */
4007 strcpy (packet
, "0");
4011 sprintf (packet
, "%x", target_get_min_fast_tracepoint_insn_len ());
4014 /* Respond to qTBuffer packet with a block of raw data from the trace
4015 buffer. GDB may ask for a lot, but we are allowed to reply with
4016 only as much as will fit within packet limits or whatever. */
4019 cmd_qtbuffer (char *own_buf
)
4021 ULONGEST offset
, num
, tot
;
4023 char *packet
= own_buf
;
4025 packet
+= strlen ("qTBuffer:");
4027 packet
= unpack_varlen_hex (packet
, &offset
);
4028 ++packet
; /* skip a comma */
4029 unpack_varlen_hex (packet
, &num
);
4031 trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s",
4032 (int) num
, phex_nz (offset
, 0));
4034 tot
= (trace_buffer_hi
- trace_buffer_lo
) - free_space ();
4036 /* If we're right at the end, reply specially that we're done. */
4039 strcpy (own_buf
, "l");
4043 /* Object to any other out-of-bounds request. */
4046 write_enn (own_buf
);
4050 /* Compute the pointer corresponding to the given offset, accounting
4052 tbp
= trace_buffer_start
+ offset
;
4053 if (tbp
>= trace_buffer_wrap
)
4054 tbp
-= (trace_buffer_wrap
- trace_buffer_lo
);
4056 /* Trim to the remaining bytes if we're close to the end. */
4057 if (num
> tot
- offset
)
4060 /* Trim to available packet size. */
4061 if (num
>= (PBUFSIZ
- 16) / 2 )
4062 num
= (PBUFSIZ
- 16) / 2;
4064 bin2hex (tbp
, own_buf
, num
);
4068 cmd_bigqtbuffer_circular (char *own_buf
)
4071 char *packet
= own_buf
;
4073 packet
+= strlen ("QTBuffer:circular:");
4075 unpack_varlen_hex (packet
, &val
);
4076 circular_trace_buffer
= val
;
4077 trace_debug ("Trace buffer is now %s",
4078 circular_trace_buffer
? "circular" : "linear");
4083 cmd_bigqtbuffer_size (char *own_buf
)
4087 char *packet
= own_buf
;
4089 /* Can't change the size during a tracing run. */
4092 write_enn (own_buf
);
4096 packet
+= strlen ("QTBuffer:size:");
4098 /* -1 is sent as literal "-1". */
4099 if (strcmp (packet
, "-1") == 0)
4100 sval
= DEFAULT_TRACE_BUFFER_SIZE
;
4103 unpack_varlen_hex (packet
, &val
);
4104 sval
= (LONGEST
) val
;
4107 init_trace_buffer (sval
);
4108 trace_debug ("Trace buffer is now %s bytes",
4109 plongest (trace_buffer_size
));
4114 cmd_qtnotes (char *own_buf
)
4117 char *saved
, *user
, *notes
, *stopnote
;
4118 char *packet
= own_buf
;
4120 packet
+= strlen ("QTNotes:");
4124 if (strncmp ("user:", packet
, strlen ("user:")) == 0)
4126 packet
+= strlen ("user:");
4128 packet
= strchr (packet
, ';');
4129 nbytes
= (packet
- saved
) / 2;
4130 user
= xmalloc (nbytes
+ 1);
4131 nbytes
= hex2bin (saved
, (gdb_byte
*) user
, nbytes
);
4132 user
[nbytes
] = '\0';
4133 ++packet
; /* skip the semicolon */
4134 trace_debug ("User is '%s'", user
);
4135 xfree (tracing_user_name
);
4136 tracing_user_name
= user
;
4138 else if (strncmp ("notes:", packet
, strlen ("notes:")) == 0)
4140 packet
+= strlen ("notes:");
4142 packet
= strchr (packet
, ';');
4143 nbytes
= (packet
- saved
) / 2;
4144 notes
= xmalloc (nbytes
+ 1);
4145 nbytes
= hex2bin (saved
, (gdb_byte
*) notes
, nbytes
);
4146 notes
[nbytes
] = '\0';
4147 ++packet
; /* skip the semicolon */
4148 trace_debug ("Notes is '%s'", notes
);
4149 xfree (tracing_notes
);
4150 tracing_notes
= notes
;
4152 else if (strncmp ("tstop:", packet
, strlen ("tstop:")) == 0)
4154 packet
+= strlen ("tstop:");
4156 packet
= strchr (packet
, ';');
4157 nbytes
= (packet
- saved
) / 2;
4158 stopnote
= xmalloc (nbytes
+ 1);
4159 nbytes
= hex2bin (saved
, (gdb_byte
*) stopnote
, nbytes
);
4160 stopnote
[nbytes
] = '\0';
4161 ++packet
; /* skip the semicolon */
4162 trace_debug ("tstop note is '%s'", stopnote
);
4163 xfree (tracing_stop_note
);
4164 tracing_stop_note
= stopnote
;
4174 handle_tracepoint_general_set (char *packet
)
4176 if (strcmp ("QTinit", packet
) == 0)
4178 cmd_qtinit (packet
);
4181 else if (strncmp ("QTDP:", packet
, strlen ("QTDP:")) == 0)
4186 else if (strncmp ("QTDPsrc:", packet
, strlen ("QTDPsrc:")) == 0)
4188 cmd_qtdpsrc (packet
);
4191 else if (strncmp ("QTEnable:", packet
, strlen ("QTEnable:")) == 0)
4193 cmd_qtenable_disable (packet
, 1);
4196 else if (strncmp ("QTDisable:", packet
, strlen ("QTDisable:")) == 0)
4198 cmd_qtenable_disable (packet
, 0);
4201 else if (strncmp ("QTDV:", packet
, strlen ("QTDV:")) == 0)
4206 else if (strncmp ("QTro:", packet
, strlen ("QTro:")) == 0)
4211 else if (strcmp ("QTStart", packet
) == 0)
4213 cmd_qtstart (packet
);
4216 else if (strcmp ("QTStop", packet
) == 0)
4218 cmd_qtstop (packet
);
4221 else if (strncmp ("QTDisconnected:", packet
,
4222 strlen ("QTDisconnected:")) == 0)
4224 cmd_qtdisconnected (packet
);
4227 else if (strncmp ("QTFrame:", packet
, strlen ("QTFrame:")) == 0)
4229 cmd_qtframe (packet
);
4232 else if (strncmp ("QTBuffer:circular:", packet
, strlen ("QTBuffer:circular:")) == 0)
4234 cmd_bigqtbuffer_circular (packet
);
4237 else if (strncmp ("QTBuffer:size:", packet
, strlen ("QTBuffer:size:")) == 0)
4239 cmd_bigqtbuffer_size (packet
);
4242 else if (strncmp ("QTNotes:", packet
, strlen ("QTNotes:")) == 0)
4244 cmd_qtnotes (packet
);
4252 handle_tracepoint_query (char *packet
)
4254 if (strcmp ("qTStatus", packet
) == 0)
4256 cmd_qtstatus (packet
);
4259 else if (strncmp ("qTP:", packet
, strlen ("qTP:")) == 0)
4264 else if (strcmp ("qTfP", packet
) == 0)
4269 else if (strcmp ("qTsP", packet
) == 0)
4274 else if (strcmp ("qTfV", packet
) == 0)
4279 else if (strcmp ("qTsV", packet
) == 0)
4284 else if (strncmp ("qTV:", packet
, strlen ("qTV:")) == 0)
4289 else if (strncmp ("qTBuffer:", packet
, strlen ("qTBuffer:")) == 0)
4291 cmd_qtbuffer (packet
);
4294 else if (strcmp ("qTfSTM", packet
) == 0)
4296 cmd_qtfstm (packet
);
4299 else if (strcmp ("qTsSTM", packet
) == 0)
4301 cmd_qtsstm (packet
);
4304 else if (strncmp ("qTSTMat:", packet
, strlen ("qTSTMat:")) == 0)
4306 cmd_qtstmat (packet
);
4309 else if (strcmp ("qTMinFTPILen", packet
) == 0)
4311 cmd_qtminftpilen (packet
);
4319 #ifndef IN_PROCESS_AGENT
4321 /* Call this when thread TINFO has hit the tracepoint defined by
4322 TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping
4323 action. This adds a while-stepping collecting state item to the
4324 threads' collecting state list, so that we can keep track of
4325 multiple simultaneous while-stepping actions being collected by the
4326 same thread. This can happen in cases like:
4328 ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs
4330 ff0003 INSN3 <-- TP2, collect $regs
4331 ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs
4334 Notice that when instruction INSN5 is reached, the while-stepping
4335 actions of both TP1 and TP3 are still being collected, and that TP2
4336 had been collected meanwhile. The whole range of ff0001-ff0005
4337 should be single-stepped, due to at least TP1's while-stepping
4338 action covering the whole range. */
4341 add_while_stepping_state (struct thread_info
*tinfo
,
4342 int tp_number
, CORE_ADDR tp_address
)
4344 struct wstep_state
*wstep
;
4346 wstep
= xmalloc (sizeof (*wstep
));
4347 wstep
->next
= tinfo
->while_stepping
;
4349 wstep
->tp_number
= tp_number
;
4350 wstep
->tp_address
= tp_address
;
4351 wstep
->current_step
= 0;
4353 tinfo
->while_stepping
= wstep
;
4356 /* Release the while-stepping collecting state WSTEP. */
4359 release_while_stepping_state (struct wstep_state
*wstep
)
4364 /* Release all while-stepping collecting states currently associated
4365 with thread TINFO. */
4368 release_while_stepping_state_list (struct thread_info
*tinfo
)
4370 struct wstep_state
*head
;
4372 while (tinfo
->while_stepping
)
4374 head
= tinfo
->while_stepping
;
4375 tinfo
->while_stepping
= head
->next
;
4376 release_while_stepping_state (head
);
4380 /* If TINFO was handling a 'while-stepping' action, the step has
4381 finished, so collect any step data needed, and check if any more
4382 steps are required. Return true if the thread was indeed
4383 collecting tracepoint data, false otherwise. */
4386 tracepoint_finished_step (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4388 struct tracepoint
*tpoint
;
4389 struct wstep_state
*wstep
;
4390 struct wstep_state
**wstep_link
;
4391 struct trap_tracepoint_ctx ctx
;
4393 /* Pull in fast tracepoint trace frames from the inferior lib buffer into
4395 if (agent_loaded_p ())
4396 upload_fast_traceframes ();
4398 /* Check if we were indeed collecting data for one of more
4399 tracepoints with a 'while-stepping' count. */
4400 if (tinfo
->while_stepping
== NULL
)
4405 /* We're not even tracing anymore. Stop this thread from
4407 release_while_stepping_state_list (tinfo
);
4409 /* The thread had stopped due to a single-step request indeed
4410 explained by a tracepoint. */
4414 wstep
= tinfo
->while_stepping
;
4415 wstep_link
= &tinfo
->while_stepping
;
4417 trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
4418 target_pid_to_str (tinfo
->entry
.id
),
4419 wstep
->tp_number
, paddress (wstep
->tp_address
));
4421 ctx
.base
.type
= trap_tracepoint
;
4422 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4424 while (wstep
!= NULL
)
4426 tpoint
= find_tracepoint (wstep
->tp_number
, wstep
->tp_address
);
4429 trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
4430 wstep
->tp_number
, paddress (wstep
->tp_address
),
4431 target_pid_to_str (tinfo
->entry
.id
));
4434 *wstep_link
= wstep
->next
;
4435 release_while_stepping_state (wstep
);
4436 wstep
= *wstep_link
;
4440 /* We've just finished one step. */
4441 ++wstep
->current_step
;
4444 collect_data_at_step ((struct tracepoint_hit_ctx
*) &ctx
,
4445 stop_pc
, tpoint
, wstep
->current_step
);
4447 if (wstep
->current_step
>= tpoint
->step_count
)
4449 /* The requested numbers of steps have occurred. */
4450 trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
4451 target_pid_to_str (tinfo
->entry
.id
),
4452 wstep
->tp_number
, paddress (wstep
->tp_address
));
4454 /* Unlink the wstep. */
4455 *wstep_link
= wstep
->next
;
4456 release_while_stepping_state (wstep
);
4457 wstep
= *wstep_link
;
4459 /* Only check the hit count now, which ensure that we do all
4460 our stepping before stopping the run. */
4461 if (tpoint
->pass_count
> 0
4462 && tpoint
->hit_count
>= tpoint
->pass_count
4463 && stopping_tracepoint
== NULL
)
4464 stopping_tracepoint
= tpoint
;
4468 /* Keep single-stepping until the requested numbers of steps
4470 wstep_link
= &wstep
->next
;
4471 wstep
= *wstep_link
;
4474 if (stopping_tracepoint
4475 || trace_buffer_is_full
4476 || expr_eval_result
!= expr_eval_no_error
)
4486 /* Handle any internal tracing control breakpoint hits. That means,
4487 pull traceframes from the IPA to our buffer, and syncing both
4488 tracing agents when the IPA's tracing stops for some reason. */
4491 handle_tracepoint_bkpts (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4493 /* Pull in fast tracepoint trace frames from the inferior in-process
4494 agent's buffer into our buffer. */
4496 if (!agent_loaded_p ())
4499 upload_fast_traceframes ();
4501 /* Check if the in-process agent had decided we should stop
4503 if (stop_pc
== ipa_sym_addrs
.addr_stop_tracing
)
4505 int ipa_trace_buffer_is_full
;
4506 CORE_ADDR ipa_stopping_tracepoint
;
4507 int ipa_expr_eval_result
;
4508 CORE_ADDR ipa_error_tracepoint
;
4510 trace_debug ("lib stopped at stop_tracing");
4512 read_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
,
4513 &ipa_trace_buffer_is_full
);
4515 read_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
4516 &ipa_stopping_tracepoint
);
4517 write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
, 0);
4519 read_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
,
4520 &ipa_error_tracepoint
);
4521 write_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
, 0);
4523 read_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
,
4524 &ipa_expr_eval_result
);
4525 write_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
, 0);
4527 trace_debug ("lib: trace_buffer_is_full: %d, "
4528 "stopping_tracepoint: %s, "
4529 "ipa_expr_eval_result: %d, "
4530 "error_tracepoint: %s, ",
4531 ipa_trace_buffer_is_full
,
4532 paddress (ipa_stopping_tracepoint
),
4533 ipa_expr_eval_result
,
4534 paddress (ipa_error_tracepoint
));
4538 if (ipa_trace_buffer_is_full
)
4539 trace_debug ("lib stopped due to full buffer.");
4540 if (ipa_stopping_tracepoint
)
4541 trace_debug ("lib stopped due to tpoint");
4542 if (ipa_stopping_tracepoint
)
4543 trace_debug ("lib stopped due to error");
4546 if (ipa_stopping_tracepoint
!= 0)
4549 = fast_tracepoint_from_ipa_tpoint_address (ipa_stopping_tracepoint
);
4551 else if (ipa_expr_eval_result
!= expr_eval_no_error
)
4553 expr_eval_result
= ipa_expr_eval_result
;
4555 = fast_tracepoint_from_ipa_tpoint_address (ipa_error_tracepoint
);
4560 else if (stop_pc
== ipa_sym_addrs
.addr_flush_trace_buffer
)
4562 trace_debug ("lib stopped at flush_trace_buffer");
4569 /* Return true if TINFO just hit a tracepoint. Collect data if
4573 tracepoint_was_hit (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4575 struct tracepoint
*tpoint
;
4577 struct trap_tracepoint_ctx ctx
;
4579 /* Not tracing, don't handle. */
4583 ctx
.base
.type
= trap_tracepoint
;
4584 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4586 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
4588 /* Note that we collect fast tracepoints here as well. We'll
4589 step over the fast tracepoint jump later, which avoids the
4590 double collect. However, we don't collect for static
4591 tracepoints here, because UST markers are compiled in program,
4592 and probes will be executed in program. So static tracepoints
4593 are collected there. */
4594 if (tpoint
->enabled
&& stop_pc
== tpoint
->address
4595 && tpoint
->type
!= static_tracepoint
)
4597 trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
4598 target_pid_to_str (tinfo
->entry
.id
),
4599 tpoint
->number
, paddress (tpoint
->address
));
4601 /* Test the condition if present, and collect if true. */
4603 || (condition_true_at_tracepoint
4604 ((struct tracepoint_hit_ctx
*) &ctx
, tpoint
)))
4605 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
4608 if (stopping_tracepoint
4609 || trace_buffer_is_full
4610 || expr_eval_result
!= expr_eval_no_error
)
4614 /* If the tracepoint had a 'while-stepping' action, then set
4615 the thread to collect this tracepoint on the following
4617 else if (tpoint
->step_count
> 0)
4619 add_while_stepping_state (tinfo
,
4620 tpoint
->number
, tpoint
->address
);
4632 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4633 struct ust_marker_data
;
4634 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4635 struct traceframe
*tframe
);
4638 /* Create a trace frame for the hit of the given tracepoint in the
4642 collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
, CORE_ADDR stop_pc
,
4643 struct tracepoint
*tpoint
)
4645 struct traceframe
*tframe
;
4648 /* Only count it as a hit when we actually collect data. */
4649 tpoint
->hit_count
++;
4651 /* If we've exceeded a defined pass count, record the event for
4652 later, and finish the collection for this hit. This test is only
4653 for nonstepping tracepoints, stepping tracepoints test at the end
4654 of their while-stepping loop. */
4655 if (tpoint
->pass_count
> 0
4656 && tpoint
->hit_count
>= tpoint
->pass_count
4657 && tpoint
->step_count
== 0
4658 && stopping_tracepoint
== NULL
)
4659 stopping_tracepoint
= tpoint
;
4661 trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64
,
4662 tpoint
->number
, paddress (tpoint
->address
), tpoint
->hit_count
);
4664 tframe
= add_traceframe (tpoint
);
4668 for (acti
= 0; acti
< tpoint
->numactions
; ++acti
)
4670 #ifndef IN_PROCESS_AGENT
4671 trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
4672 tpoint
->number
, paddress (tpoint
->address
),
4673 tpoint
->actions_str
[acti
]);
4676 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4677 tpoint
->actions
[acti
]);
4680 finish_traceframe (tframe
);
4683 if (tframe
== NULL
&& tracing
)
4684 trace_buffer_is_full
= 1;
4687 #ifndef IN_PROCESS_AGENT
4690 collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
4692 struct tracepoint
*tpoint
, int current_step
)
4694 struct traceframe
*tframe
;
4697 trace_debug ("Making new step traceframe for "
4698 "tracepoint %d at 0x%s, step %d of %" PRIu64
", hit %" PRIu64
,
4699 tpoint
->number
, paddress (tpoint
->address
),
4700 current_step
, tpoint
->step_count
,
4703 tframe
= add_traceframe (tpoint
);
4707 for (acti
= 0; acti
< tpoint
->num_step_actions
; ++acti
)
4709 trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'",
4710 tpoint
->number
, paddress (tpoint
->address
),
4711 tpoint
->step_actions_str
[acti
]);
4713 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4714 tpoint
->step_actions
[acti
]);
4717 finish_traceframe (tframe
);
4720 if (tframe
== NULL
&& tracing
)
4721 trace_buffer_is_full
= 1;
4726 #ifdef IN_PROCESS_AGENT
4727 /* The target description used by the IPA. Given that the IPA library
4728 is built for a specific architecture that is loaded into the
4729 inferior, there only needs to be one such description per
4731 const struct target_desc
*ipa_tdesc
;
4734 static struct regcache
*
4735 get_context_regcache (struct tracepoint_hit_ctx
*ctx
)
4737 struct regcache
*regcache
= NULL
;
4739 #ifdef IN_PROCESS_AGENT
4740 if (ctx
->type
== fast_tracepoint
)
4742 struct fast_tracepoint_ctx
*fctx
= (struct fast_tracepoint_ctx
*) ctx
;
4743 if (!fctx
->regcache_initted
)
4745 fctx
->regcache_initted
= 1;
4746 init_register_cache (&fctx
->regcache
, ipa_tdesc
, fctx
->regspace
);
4747 supply_regblock (&fctx
->regcache
, NULL
);
4748 supply_fast_tracepoint_registers (&fctx
->regcache
, fctx
->regs
);
4750 regcache
= &fctx
->regcache
;
4753 if (ctx
->type
== static_tracepoint
)
4755 struct static_tracepoint_ctx
*sctx
4756 = (struct static_tracepoint_ctx
*) ctx
;
4758 if (!sctx
->regcache_initted
)
4760 sctx
->regcache_initted
= 1;
4761 init_register_cache (&sctx
->regcache
, ipa_tdesc
, sctx
->regspace
);
4762 supply_regblock (&sctx
->regcache
, NULL
);
4763 /* Pass down the tracepoint address, because REGS doesn't
4764 include the PC, but we know what it must have been. */
4765 supply_static_tracepoint_registers (&sctx
->regcache
,
4766 (const unsigned char *)
4768 sctx
->tpoint
->address
);
4770 regcache
= &sctx
->regcache
;
4774 if (ctx
->type
== trap_tracepoint
)
4776 struct trap_tracepoint_ctx
*tctx
= (struct trap_tracepoint_ctx
*) ctx
;
4777 regcache
= tctx
->regcache
;
4781 gdb_assert (regcache
!= NULL
);
4787 do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4789 struct tracepoint
*tpoint
,
4790 struct traceframe
*tframe
,
4791 struct tracepoint_action
*taction
)
4793 enum eval_result_type err
;
4795 switch (taction
->type
)
4799 struct collect_memory_action
*maction
;
4800 struct eval_agent_expr_context ax_ctx
;
4802 maction
= (struct collect_memory_action
*) taction
;
4803 ax_ctx
.regcache
= NULL
;
4804 ax_ctx
.tframe
= tframe
;
4805 ax_ctx
.tpoint
= tpoint
;
4807 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
4808 pulongest (maction
->len
),
4809 paddress (maction
->addr
), maction
->basereg
);
4810 /* (should use basereg) */
4811 agent_mem_read (&ax_ctx
, NULL
, (CORE_ADDR
) maction
->addr
,
4817 unsigned char *regspace
;
4818 struct regcache tregcache
;
4819 struct regcache
*context_regcache
;
4822 trace_debug ("Want to collect registers");
4824 context_regcache
= get_context_regcache (ctx
);
4825 regcache_size
= register_cache_size (context_regcache
->tdesc
);
4827 /* Collect all registers for now. */
4828 regspace
= add_traceframe_block (tframe
, tpoint
, 1 + regcache_size
);
4829 if (regspace
== NULL
)
4831 trace_debug ("Trace buffer block allocation failed, skipping");
4834 /* Identify a register block. */
4837 /* Wrap the regblock in a register cache (in the stack, we
4838 don't want to malloc here). */
4839 init_register_cache (&tregcache
, context_regcache
->tdesc
,
4842 /* Copy the register data to the regblock. */
4843 regcache_cpy (&tregcache
, context_regcache
);
4845 #ifndef IN_PROCESS_AGENT
4846 /* On some platforms, trap-based tracepoints will have the PC
4847 pointing to the next instruction after the trap, but we
4848 don't want the user or GDB trying to guess whether the
4849 saved PC needs adjusting; so always record the adjusted
4850 stop_pc. Note that we can't use tpoint->address instead,
4851 since it will be wrong for while-stepping actions. This
4852 adjustment is a nop for fast tracepoints collected from the
4853 in-process lib (but not if GDBserver is collecting one
4854 preemptively), since the PC had already been adjusted to
4855 contain the tracepoint's address by the jump pad. */
4856 trace_debug ("Storing stop pc (0x%s) in regblock",
4857 paddress (stop_pc
));
4859 /* This changes the regblock, not the thread's
4861 regcache_write_pc (&tregcache
, stop_pc
);
4867 struct eval_expr_action
*eaction
;
4868 struct eval_agent_expr_context ax_ctx
;
4870 eaction
= (struct eval_expr_action
*) taction
;
4871 ax_ctx
.regcache
= get_context_regcache (ctx
);
4872 ax_ctx
.tframe
= tframe
;
4873 ax_ctx
.tpoint
= tpoint
;
4875 trace_debug ("Want to evaluate expression");
4877 err
= gdb_eval_agent_expr (&ax_ctx
, eaction
->expr
, NULL
);
4879 if (err
!= expr_eval_no_error
)
4881 record_tracepoint_error (tpoint
, "action expression", err
);
4888 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4889 trace_debug ("Want to collect static trace data");
4890 collect_ust_data_at_tracepoint (ctx
, tframe
);
4892 trace_debug ("warning: collecting static trace data, "
4893 "but static tracepoints are not supported");
4898 trace_debug ("unknown trace action '%c', ignoring", taction
->type
);
4904 condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4905 struct tracepoint
*tpoint
)
4908 enum eval_result_type err
;
4910 /* Presently, gdbserver doesn't run compiled conditions, only the
4911 IPA does. If the program stops at a fast tracepoint's address
4912 (e.g., due to a breakpoint, trap tracepoint, or stepping),
4913 gdbserver preemptively collect the fast tracepoint. Later, on
4914 resume, gdbserver steps over the fast tracepoint like it steps
4915 over breakpoints, so that the IPA doesn't see that fast
4916 tracepoint. This avoids double collects of fast tracepoints in
4917 that stopping scenario. Having gdbserver itself handle the fast
4918 tracepoint gives the user a consistent view of when fast or trap
4919 tracepoints are collected, compared to an alternative where only
4920 trap tracepoints are collected on stop, and fast tracepoints on
4921 resume. When a fast tracepoint is being processed by gdbserver,
4922 it is always the non-compiled condition expression that is
4924 #ifdef IN_PROCESS_AGENT
4925 if (tpoint
->compiled_cond
)
4926 err
= ((condfn
) (uintptr_t) (tpoint
->compiled_cond
)) (ctx
, &value
);
4930 struct eval_agent_expr_context ax_ctx
;
4932 ax_ctx
.regcache
= get_context_regcache (ctx
);
4933 ax_ctx
.tframe
= NULL
;
4934 ax_ctx
.tpoint
= tpoint
;
4936 err
= gdb_eval_agent_expr (&ax_ctx
, tpoint
->cond
, &value
);
4938 if (err
!= expr_eval_no_error
)
4940 record_tracepoint_error (tpoint
, "condition", err
);
4941 /* The error case must return false. */
4945 trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
4946 tpoint
->number
, paddress (tpoint
->address
),
4948 return (value
? 1 : 0);
4951 /* Do memory copies for bytecodes. */
4952 /* Do the recording of memory blocks for actions and bytecodes. */
4955 agent_mem_read (struct eval_agent_expr_context
*ctx
,
4956 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4958 unsigned char *mspace
;
4959 ULONGEST remaining
= len
;
4960 unsigned short blocklen
;
4962 /* If a 'to' buffer is specified, use it. */
4965 read_inferior_memory (from
, to
, len
);
4969 /* Otherwise, create a new memory block in the trace buffer. */
4970 while (remaining
> 0)
4974 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4975 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
4976 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
4979 /* Identify block as a memory block. */
4982 /* Record address and size. */
4983 memcpy (mspace
, &from
, sizeof (from
));
4984 mspace
+= sizeof (from
);
4985 memcpy (mspace
, &blocklen
, sizeof (blocklen
));
4986 mspace
+= sizeof (blocklen
);
4987 /* Record the memory block proper. */
4988 read_inferior_memory (from
, mspace
, blocklen
);
4989 trace_debug ("%d bytes recorded", blocklen
);
4990 remaining
-= blocklen
;
4997 agent_mem_read_string (struct eval_agent_expr_context
*ctx
,
4998 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
5000 unsigned char *buf
, *mspace
;
5001 ULONGEST remaining
= len
;
5002 unsigned short blocklen
, i
;
5004 /* To save a bit of space, block lengths are 16-bit, so break large
5005 requests into multiple blocks. Bordering on overkill for strings,
5006 but it could happen that someone specifies a large max length. */
5007 while (remaining
> 0)
5011 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
5012 /* We want working space to accumulate nonzero bytes, since
5013 traceframes must have a predecided size (otherwise it gets
5014 harder to wrap correctly for the circular case, etc). */
5015 buf
= (unsigned char *) xmalloc (blocklen
+ 1);
5016 for (i
= 0; i
< blocklen
; ++i
)
5018 /* Read the string one byte at a time, in case the string is
5019 at the end of a valid memory area - we don't want a
5020 correctly-terminated string to engender segvio
5022 read_inferior_memory (from
+ i
, buf
+ i
, 1);
5027 /* Make sure outer loop stops now too. */
5028 remaining
= blocklen
;
5032 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
5033 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
5039 /* Identify block as a memory block. */
5042 /* Record address and size. */
5043 memcpy ((void *) mspace
, (void *) &from
, sizeof (from
));
5044 mspace
+= sizeof (from
);
5045 memcpy ((void *) mspace
, (void *) &blocklen
, sizeof (blocklen
));
5046 mspace
+= sizeof (blocklen
);
5047 /* Copy the string contents. */
5048 memcpy ((void *) mspace
, (void *) buf
, blocklen
);
5049 remaining
-= blocklen
;
5056 /* Record the value of a trace state variable. */
5059 agent_tsv_read (struct eval_agent_expr_context
*ctx
, int n
)
5061 unsigned char *vspace
;
5064 vspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
,
5065 1 + sizeof (n
) + sizeof (LONGEST
));
5068 /* Identify block as a variable. */
5070 /* Record variable's number and value. */
5071 memcpy (vspace
+ 1, &n
, sizeof (n
));
5072 val
= get_trace_state_variable_value (n
);
5073 memcpy (vspace
+ 1 + sizeof (n
), &val
, sizeof (val
));
5074 trace_debug ("Variable %d recorded", n
);
5078 #ifndef IN_PROCESS_AGENT
5080 /* Callback for traceframe_walk_blocks, used to find a given block
5081 type in a traceframe. */
5084 match_blocktype (char blocktype
, unsigned char *dataptr
, void *data
)
5086 char *wantedp
= data
;
5088 if (*wantedp
== blocktype
)
5094 /* Walk over all traceframe blocks of the traceframe buffer starting
5095 at DATABASE, of DATASIZE bytes long, and call CALLBACK for each
5096 block found, passing in DATA unmodified. If CALLBACK returns true,
5097 this returns a pointer to where the block is found. Returns NULL
5098 if no callback call returned true, indicating that all blocks have
5101 static unsigned char *
5102 traceframe_walk_blocks (unsigned char *database
, unsigned int datasize
,
5104 int (*callback
) (char blocktype
,
5105 unsigned char *dataptr
,
5109 unsigned char *dataptr
;
5113 trace_debug ("traceframe %d has no data", tfnum
);
5117 /* Iterate through a traceframe's blocks, looking for a block of the
5119 for (dataptr
= database
;
5120 dataptr
< database
+ datasize
;
5124 unsigned short mlen
;
5126 if (dataptr
== trace_buffer_wrap
)
5128 /* Adjust to reflect wrapping part of the frame around to
5130 datasize
= dataptr
- database
;
5131 dataptr
= database
= trace_buffer_lo
;
5134 blocktype
= *dataptr
++;
5136 if ((*callback
) (blocktype
, dataptr
, data
))
5142 /* Skip over the registers block. */
5143 dataptr
+= current_target_desc ()->registers_size
;
5146 /* Skip over the memory block. */
5147 dataptr
+= sizeof (CORE_ADDR
);
5148 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5149 dataptr
+= (sizeof (mlen
) + mlen
);
5152 /* Skip over the TSV block. */
5153 dataptr
+= (sizeof (int) + sizeof (LONGEST
));
5156 /* Skip over the static trace data block. */
5157 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5158 dataptr
+= (sizeof (mlen
) + mlen
);
5161 trace_debug ("traceframe %d has unknown block type 0x%x",
5170 /* Look for the block of type TYPE_WANTED in the trameframe starting
5171 at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
5174 static unsigned char *
5175 traceframe_find_block_type (unsigned char *database
, unsigned int datasize
,
5176 int tfnum
, char type_wanted
)
5178 return traceframe_walk_blocks (database
, datasize
, tfnum
,
5179 match_blocktype
, &type_wanted
);
5182 static unsigned char *
5183 traceframe_find_regblock (struct traceframe
*tframe
, int tfnum
)
5185 unsigned char *regblock
;
5187 regblock
= traceframe_find_block_type (tframe
->data
,
5191 if (regblock
== NULL
)
5192 trace_debug ("traceframe %d has no register data", tfnum
);
5197 /* Get registers from a traceframe. */
5200 fetch_traceframe_registers (int tfnum
, struct regcache
*regcache
, int regnum
)
5202 unsigned char *dataptr
;
5203 struct tracepoint
*tpoint
;
5204 struct traceframe
*tframe
;
5206 tframe
= find_traceframe (tfnum
);
5210 trace_debug ("traceframe %d not found", tfnum
);
5214 dataptr
= traceframe_find_regblock (tframe
, tfnum
);
5215 if (dataptr
== NULL
)
5217 /* Mark registers unavailable. */
5218 supply_regblock (regcache
, NULL
);
5220 /* We can generally guess at a PC, although this will be
5221 misleading for while-stepping frames and multi-location
5223 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
5225 regcache_write_pc (regcache
, tpoint
->address
);
5228 supply_regblock (regcache
, dataptr
);
5234 traceframe_get_pc (struct traceframe
*tframe
)
5236 struct regcache regcache
;
5237 unsigned char *dataptr
;
5238 const struct target_desc
*tdesc
= current_target_desc ();
5240 dataptr
= traceframe_find_regblock (tframe
, -1);
5241 if (dataptr
== NULL
)
5244 init_register_cache (®cache
, tdesc
, dataptr
);
5245 return regcache_read_pc (®cache
);
5248 /* Read a requested block of memory from a trace frame. */
5251 traceframe_read_mem (int tfnum
, CORE_ADDR addr
,
5252 unsigned char *buf
, ULONGEST length
,
5255 struct traceframe
*tframe
;
5256 unsigned char *database
, *dataptr
;
5257 unsigned int datasize
;
5259 unsigned short mlen
;
5261 trace_debug ("traceframe_read_mem");
5263 tframe
= find_traceframe (tfnum
);
5267 trace_debug ("traceframe %d not found", tfnum
);
5271 datasize
= tframe
->data_size
;
5272 database
= dataptr
= &tframe
->data
[0];
5274 /* Iterate through a traceframe's blocks, looking for memory. */
5275 while ((dataptr
= traceframe_find_block_type (dataptr
,
5277 - (dataptr
- database
),
5278 tfnum
, 'M')) != NULL
)
5280 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5281 dataptr
+= sizeof (maddr
);
5282 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5283 dataptr
+= sizeof (mlen
);
5284 trace_debug ("traceframe %d has %d bytes at %s",
5285 tfnum
, mlen
, paddress (maddr
));
5287 /* If the block includes the first part of the desired range,
5288 return as much it has; GDB will re-request the remainder,
5289 which might be in a different block of this trace frame. */
5290 if (maddr
<= addr
&& addr
< (maddr
+ mlen
))
5292 ULONGEST amt
= (maddr
+ mlen
) - addr
;
5296 memcpy (buf
, dataptr
+ (addr
- maddr
), amt
);
5301 /* Skip over this block. */
5305 trace_debug ("traceframe %d has no memory data for the desired region",
5313 traceframe_read_tsv (int tsvnum
, LONGEST
*val
)
5316 struct traceframe
*tframe
;
5317 unsigned char *database
, *dataptr
;
5318 unsigned int datasize
;
5322 trace_debug ("traceframe_read_tsv");
5324 tfnum
= current_traceframe
;
5328 trace_debug ("no current traceframe");
5332 tframe
= find_traceframe (tfnum
);
5336 trace_debug ("traceframe %d not found", tfnum
);
5340 datasize
= tframe
->data_size
;
5341 database
= dataptr
= &tframe
->data
[0];
5343 /* Iterate through a traceframe's blocks, looking for the last
5345 while ((dataptr
= traceframe_find_block_type (dataptr
,
5347 - (dataptr
- database
),
5348 tfnum
, 'V')) != NULL
)
5350 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5351 dataptr
+= sizeof (vnum
);
5353 trace_debug ("traceframe %d has variable %d", tfnum
, vnum
);
5355 /* Check that this is the variable we want. */
5358 memcpy (val
, dataptr
, sizeof (*val
));
5362 /* Skip over this block. */
5363 dataptr
+= sizeof (LONGEST
);
5367 trace_debug ("traceframe %d has no data for variable %d",
5372 /* Read a requested block of static tracepoint data from a trace
5376 traceframe_read_sdata (int tfnum
, ULONGEST offset
,
5377 unsigned char *buf
, ULONGEST length
,
5380 struct traceframe
*tframe
;
5381 unsigned char *database
, *dataptr
;
5382 unsigned int datasize
;
5383 unsigned short mlen
;
5385 trace_debug ("traceframe_read_sdata");
5387 tframe
= find_traceframe (tfnum
);
5391 trace_debug ("traceframe %d not found", tfnum
);
5395 datasize
= tframe
->data_size
;
5396 database
= &tframe
->data
[0];
5398 /* Iterate through a traceframe's blocks, looking for static
5400 dataptr
= traceframe_find_block_type (database
, datasize
,
5402 if (dataptr
!= NULL
)
5404 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5405 dataptr
+= sizeof (mlen
);
5408 if (offset
+ length
> mlen
)
5409 length
= mlen
- offset
;
5411 memcpy (buf
, dataptr
, length
);
5419 trace_debug ("traceframe %d has no static trace data", tfnum
);
5425 /* Callback for traceframe_walk_blocks. Builds a traceframe-info
5426 object. DATA is pointer to a struct buffer holding the
5427 traceframe-info object being built. */
5430 build_traceframe_info_xml (char blocktype
, unsigned char *dataptr
, void *data
)
5432 struct buffer
*buffer
= data
;
5438 unsigned short mlen
;
5441 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5442 dataptr
+= sizeof (maddr
);
5443 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5444 dataptr
+= sizeof (mlen
);
5445 buffer_xml_printf (buffer
,
5446 "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5447 paddress (maddr
), phex_nz (mlen
, sizeof (mlen
)));
5454 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5455 buffer_xml_printf (buffer
, "<tvar id=\"%d\"/>\n", vnum
);
5464 warning ("Unhandled trace block type (%d) '%c ' "
5465 "while building trace frame info.",
5466 blocktype
, blocktype
);
5473 /* Build a traceframe-info object for traceframe number TFNUM into
5477 traceframe_read_info (int tfnum
, struct buffer
*buffer
)
5479 struct traceframe
*tframe
;
5481 trace_debug ("traceframe_read_info");
5483 tframe
= find_traceframe (tfnum
);
5487 trace_debug ("traceframe %d not found", tfnum
);
5491 buffer_grow_str (buffer
, "<traceframe-info>\n");
5492 traceframe_walk_blocks (tframe
->data
, tframe
->data_size
,
5493 tfnum
, build_traceframe_info_xml
, buffer
);
5494 buffer_grow_str0 (buffer
, "</traceframe-info>\n");
5498 /* Return the first fast tracepoint whose jump pad contains PC. */
5500 static struct tracepoint
*
5501 fast_tracepoint_from_jump_pad_address (CORE_ADDR pc
)
5503 struct tracepoint
*tpoint
;
5505 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5506 if (tpoint
->type
== fast_tracepoint
)
5507 if (tpoint
->jump_pad
<= pc
&& pc
< tpoint
->jump_pad_end
)
5513 /* Return the first fast tracepoint whose trampoline contains PC. */
5515 static struct tracepoint
*
5516 fast_tracepoint_from_trampoline_address (CORE_ADDR pc
)
5518 struct tracepoint
*tpoint
;
5520 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5522 if (tpoint
->type
== fast_tracepoint
5523 && tpoint
->trampoline
<= pc
&& pc
< tpoint
->trampoline_end
)
5530 /* Return GDBserver's tracepoint that matches the IP Agent's
5531 tracepoint object that lives at IPA_TPOINT_OBJ in the IP Agent's
5534 static struct tracepoint
*
5535 fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR ipa_tpoint_obj
)
5537 struct tracepoint
*tpoint
;
5539 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5540 if (tpoint
->type
== fast_tracepoint
)
5541 if (tpoint
->obj_addr_on_target
== ipa_tpoint_obj
)
5549 /* The type of the object that is used to synchronize fast tracepoint
5552 typedef struct collecting_t
5554 /* The fast tracepoint number currently collecting. */
5557 /* A number that GDBserver can use to identify the thread that is
5558 presently holding the collect lock. This need not (and usually
5559 is not) the thread id, as getting the current thread ID usually
5560 requires a system call, which we want to avoid like the plague.
5561 Usually this is thread's TCB, found in the TLS (pseudo-)
5562 register, which is readable with a single insn on several
5564 uintptr_t thread_area
;
5567 #ifndef IN_PROCESS_AGENT
5570 force_unlock_trace_buffer (void)
5572 write_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
, 0);
5575 /* Check if the thread identified by THREAD_AREA which is stopped at
5576 STOP_PC, is presently locking the fast tracepoint collection, and
5577 if so, gather some status of said collection. Returns 0 if the
5578 thread isn't collecting or in the jump pad at all. 1, if in the
5579 jump pad (or within gdb_collect) and hasn't executed the adjusted
5580 original insn yet (can set a breakpoint there and run to it). 2,
5581 if presently executing the adjusted original insn --- in which
5582 case, if we want to move the thread out of the jump pad, we need to
5583 single-step it until this function returns 0. */
5586 fast_tracepoint_collecting (CORE_ADDR thread_area
,
5588 struct fast_tpoint_collect_status
*status
)
5590 CORE_ADDR ipa_collecting
;
5591 CORE_ADDR ipa_gdb_jump_pad_buffer
, ipa_gdb_jump_pad_buffer_end
;
5592 CORE_ADDR ipa_gdb_trampoline_buffer
;
5593 CORE_ADDR ipa_gdb_trampoline_buffer_end
;
5594 struct tracepoint
*tpoint
;
5595 int needs_breakpoint
;
5597 /* The thread THREAD_AREA is either:
5599 0. not collecting at all, not within the jump pad, or within
5600 gdb_collect or one of its callees.
5602 1. in the jump pad and haven't reached gdb_collect
5604 2. within gdb_collect (out of the jump pad) (collect is set)
5606 3. we're in the jump pad, after gdb_collect having returned,
5607 possibly executing the adjusted insns.
5609 For cases 1 and 3, `collecting' may or not be set. The jump pad
5610 doesn't have any complicated jump logic, so we can tell if the
5611 thread is executing the adjust original insn or not by just
5612 matching STOP_PC with known jump pad addresses. If we it isn't
5613 yet executing the original insn, set a breakpoint there, and let
5614 the thread run to it, so to quickly step over a possible (many
5615 insns) gdb_collect call. Otherwise, or when the breakpoint is
5616 hit, only a few (small number of) insns are left to be executed
5617 in the jump pad. Single-step the thread until it leaves the
5622 needs_breakpoint
= 0;
5623 trace_debug ("fast_tracepoint_collecting");
5625 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
5626 &ipa_gdb_jump_pad_buffer
))
5628 internal_error (__FILE__
, __LINE__
,
5629 "error extracting `gdb_jump_pad_buffer'");
5631 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer_end
,
5632 &ipa_gdb_jump_pad_buffer_end
))
5634 internal_error (__FILE__
, __LINE__
,
5635 "error extracting `gdb_jump_pad_buffer_end'");
5638 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
5639 &ipa_gdb_trampoline_buffer
))
5641 internal_error (__FILE__
, __LINE__
,
5642 "error extracting `gdb_trampoline_buffer'");
5644 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
5645 &ipa_gdb_trampoline_buffer_end
))
5647 internal_error (__FILE__
, __LINE__
,
5648 "error extracting `gdb_trampoline_buffer_end'");
5651 if (ipa_gdb_jump_pad_buffer
<= stop_pc
5652 && stop_pc
< ipa_gdb_jump_pad_buffer_end
)
5654 /* We can tell which tracepoint(s) the thread is collecting by
5655 matching the jump pad address back to the tracepoint. */
5656 tpoint
= fast_tracepoint_from_jump_pad_address (stop_pc
);
5659 warning ("in jump pad, but no matching tpoint?");
5664 trace_debug ("in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5666 tpoint
->number
, paddress (tpoint
->address
),
5667 paddress (tpoint
->jump_pad
),
5668 paddress (tpoint
->jump_pad_end
),
5669 paddress (tpoint
->adjusted_insn_addr
),
5670 paddress (tpoint
->adjusted_insn_addr_end
));
5673 /* Definitely in the jump pad. May or may not need
5674 fast-exit-jump-pad breakpoint. */
5675 if (tpoint
->jump_pad
<= stop_pc
5676 && stop_pc
< tpoint
->adjusted_insn_addr
)
5677 needs_breakpoint
= 1;
5679 else if (ipa_gdb_trampoline_buffer
<= stop_pc
5680 && stop_pc
< ipa_gdb_trampoline_buffer_end
)
5682 /* We can tell which tracepoint(s) the thread is collecting by
5683 matching the trampoline address back to the tracepoint. */
5684 tpoint
= fast_tracepoint_from_trampoline_address (stop_pc
);
5687 warning ("in trampoline, but no matching tpoint?");
5692 trace_debug ("in trampoline of tpoint (%d, %s); trampoline(%s, %s)",
5693 tpoint
->number
, paddress (tpoint
->address
),
5694 paddress (tpoint
->trampoline
),
5695 paddress (tpoint
->trampoline_end
));
5698 /* Have not reached jump pad yet, but treat the trampoline as a
5699 part of the jump pad that is before the adjusted original
5701 needs_breakpoint
= 1;
5705 collecting_t ipa_collecting_obj
;
5707 /* If `collecting' is set/locked, then the THREAD_AREA thread
5708 may or not be the one holding the lock. We have to read the
5709 lock to find out. */
5711 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
,
5714 trace_debug ("fast_tracepoint_collecting:"
5715 " failed reading 'collecting' in the inferior");
5719 if (!ipa_collecting
)
5721 trace_debug ("fast_tracepoint_collecting: not collecting"
5722 " (and nobody is).");
5726 /* Some thread is collecting. Check which. */
5727 if (read_inferior_memory (ipa_collecting
,
5728 (unsigned char *) &ipa_collecting_obj
,
5729 sizeof (ipa_collecting_obj
)) != 0)
5732 if (ipa_collecting_obj
.thread_area
!= thread_area
)
5734 trace_debug ("fast_tracepoint_collecting: not collecting "
5735 "(another thread is)");
5740 = fast_tracepoint_from_ipa_tpoint_address (ipa_collecting_obj
.tpoint
);
5743 warning ("fast_tracepoint_collecting: collecting, "
5744 "but tpoint %s not found?",
5745 paddress ((CORE_ADDR
) ipa_collecting_obj
.tpoint
));
5749 /* The thread is within `gdb_collect', skip over the rest of
5750 fast tracepoint collection quickly using a breakpoint. */
5751 needs_breakpoint
= 1;
5754 /* The caller wants a bit of status detail. */
5757 status
->tpoint_num
= tpoint
->number
;
5758 status
->tpoint_addr
= tpoint
->address
;
5759 status
->adjusted_insn_addr
= tpoint
->adjusted_insn_addr
;
5760 status
->adjusted_insn_addr_end
= tpoint
->adjusted_insn_addr_end
;
5763 if (needs_breakpoint
)
5765 /* Hasn't executed the original instruction yet. Set breakpoint
5766 there, and wait till it's hit, then single-step until exiting
5770 fast_tracepoint_collecting, returning continue-until-break at %s",
5771 paddress (tpoint
->adjusted_insn_addr
));
5773 return 1; /* continue */
5777 /* Just single-step until exiting the jump pad. */
5779 trace_debug ("fast_tracepoint_collecting, returning "
5780 "need-single-step (%s-%s)",
5781 paddress (tpoint
->adjusted_insn_addr
),
5782 paddress (tpoint
->adjusted_insn_addr_end
));
5784 return 2; /* single-step */
5790 #ifdef IN_PROCESS_AGENT
5792 /* The global fast tracepoint collect lock. Points to a collecting_t
5793 object built on the stack by the jump pad, if presently locked;
5794 NULL if it isn't locked. Note that this lock *must* be set while
5795 executing any *function other than the jump pad. See
5796 fast_tracepoint_collecting. */
5797 static collecting_t
* ATTR_USED collecting
;
5799 /* This routine, called from the jump pad (in asm) is designed to be
5800 called from the jump pads of fast tracepoints, thus it is on the
5803 IP_AGENT_EXPORT
void ATTR_USED
5804 gdb_collect (struct tracepoint
*tpoint
, unsigned char *regs
)
5806 struct fast_tracepoint_ctx ctx
;
5808 /* Don't do anything until the trace run is completely set up. */
5812 ctx
.base
.type
= fast_tracepoint
;
5814 ctx
.regcache_initted
= 0;
5815 /* Wrap the regblock in a register cache (in the stack, we don't
5816 want to malloc here). */
5817 ctx
.regspace
= alloca (ipa_tdesc
->registers_size
);
5818 if (ctx
.regspace
== NULL
)
5820 trace_debug ("Trace buffer block allocation failed, skipping");
5824 for (ctx
.tpoint
= tpoint
;
5825 ctx
.tpoint
!= NULL
&& ctx
.tpoint
->address
== tpoint
->address
;
5826 ctx
.tpoint
= ctx
.tpoint
->next
)
5828 if (!ctx
.tpoint
->enabled
)
5831 /* Multiple tracepoints of different types, such as fast tracepoint and
5832 static tracepoint, can be set at the same address. */
5833 if (ctx
.tpoint
->type
!= tpoint
->type
)
5836 /* Test the condition if present, and collect if true. */
5837 if (ctx
.tpoint
->cond
== NULL
5838 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5841 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5842 ctx
.tpoint
->address
, ctx
.tpoint
);
5844 /* Note that this will cause original insns to be written back
5845 to where we jumped from, but that's OK because we're jumping
5846 back to the next whole instruction. This will go badly if
5847 instruction restoration is not atomic though. */
5848 if (stopping_tracepoint
5849 || trace_buffer_is_full
5850 || expr_eval_result
!= expr_eval_no_error
)
5858 /* If there was a condition and it evaluated to false, the only
5859 way we would stop tracing is if there was an error during
5860 condition expression evaluation. */
5861 if (expr_eval_result
!= expr_eval_no_error
)
5872 #ifndef IN_PROCESS_AGENT
5875 get_raw_reg_func_addr (void)
5877 return ipa_sym_addrs
.addr_get_raw_reg
;
5881 get_get_tsv_func_addr (void)
5883 return ipa_sym_addrs
.addr_get_trace_state_variable_value
;
5887 get_set_tsv_func_addr (void)
5889 return ipa_sym_addrs
.addr_set_trace_state_variable_value
;
5893 compile_tracepoint_condition (struct tracepoint
*tpoint
,
5894 CORE_ADDR
*jump_entry
)
5896 CORE_ADDR entry_point
= *jump_entry
;
5897 enum eval_result_type err
;
5899 trace_debug ("Starting condition compilation for tracepoint %d\n",
5902 /* Initialize the global pointer to the code being built. */
5903 current_insn_ptr
= *jump_entry
;
5907 err
= compile_bytecodes (tpoint
->cond
);
5909 if (err
== expr_eval_no_error
)
5913 /* Record the beginning of the compiled code. */
5914 tpoint
->compiled_cond
= entry_point
;
5916 trace_debug ("Condition compilation for tracepoint %d complete\n",
5921 /* Leave the unfinished code in situ, but don't point to it. */
5923 tpoint
->compiled_cond
= 0;
5925 trace_debug ("Condition compilation for tracepoint %d failed, "
5927 tpoint
->number
, err
);
5930 /* Update the code pointer passed in. Note that we do this even if
5931 the compile fails, so that we can look at the partial results
5932 instead of letting them be overwritten. */
5933 *jump_entry
= current_insn_ptr
;
5935 /* Leave a gap, to aid dump decipherment. */
5939 /* We'll need to adjust these when we consider bi-arch setups, and big
5943 write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
)
5945 return write_inferior_memory (where
,
5946 (unsigned char *) &ptr
, sizeof (void *));
5949 /* The base pointer of the IPA's heap. This is the only memory the
5950 IPA is allowed to use. The IPA should _not_ call the inferior's
5951 `malloc' during operation. That'd be slow, and, most importantly,
5952 it may not be safe. We may be collecting a tracepoint in a signal
5953 handler, for example. */
5954 static CORE_ADDR target_tp_heap
;
5956 /* Allocate at least SIZE bytes of memory from the IPA heap, aligned
5960 target_malloc (ULONGEST size
)
5964 if (target_tp_heap
== 0)
5966 /* We have the pointer *address*, need what it points to. */
5967 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_tp_heap_buffer
,
5970 internal_error (__FILE__
, __LINE__
,
5971 "couldn't get target heap head pointer");
5975 ptr
= target_tp_heap
;
5976 target_tp_heap
+= size
;
5978 /* Pad to 8-byte alignment. */
5979 target_tp_heap
= ((target_tp_heap
+ 7) & ~0x7);
5985 download_agent_expr (struct agent_expr
*expr
)
5987 CORE_ADDR expr_addr
;
5988 CORE_ADDR expr_bytes
;
5990 expr_addr
= target_malloc (sizeof (*expr
));
5991 write_inferior_memory (expr_addr
, (unsigned char *) expr
, sizeof (*expr
));
5993 expr_bytes
= target_malloc (expr
->length
);
5994 write_inferior_data_ptr (expr_addr
+ offsetof (struct agent_expr
, bytes
),
5996 write_inferior_memory (expr_bytes
, expr
->bytes
, expr
->length
);
6001 /* Align V up to N bits. */
6002 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
6004 /* Sync tracepoint with IPA, but leave maintenance of linked list to caller. */
6007 download_tracepoint_1 (struct tracepoint
*tpoint
)
6009 struct tracepoint target_tracepoint
;
6010 CORE_ADDR tpptr
= 0;
6012 gdb_assert (tpoint
->type
== fast_tracepoint
6013 || tpoint
->type
== static_tracepoint
);
6015 if (tpoint
->cond
!= NULL
&& target_emit_ops () != NULL
)
6017 CORE_ADDR jentry
, jump_entry
;
6019 jentry
= jump_entry
= get_jump_space_head ();
6021 if (tpoint
->cond
!= NULL
)
6023 /* Pad to 8-byte alignment. (needed?) */
6024 /* Actually this should be left for the target to
6026 jentry
= UALIGN (jentry
, 8);
6028 compile_tracepoint_condition (tpoint
, &jentry
);
6031 /* Pad to 8-byte alignment. */
6032 jentry
= UALIGN (jentry
, 8);
6033 claim_jump_space (jentry
- jump_entry
);
6036 target_tracepoint
= *tpoint
;
6038 tpptr
= target_malloc (sizeof (*tpoint
));
6039 tpoint
->obj_addr_on_target
= tpptr
;
6041 /* Write the whole object. We'll fix up its pointers in a bit.
6042 Assume no next for now. This is fixed up above on the next
6043 iteration, if there's any. */
6044 target_tracepoint
.next
= NULL
;
6045 /* Need to clear this here too, since we're downloading the
6046 tracepoints before clearing our own copy. */
6047 target_tracepoint
.hit_count
= 0;
6049 write_inferior_memory (tpptr
, (unsigned char *) &target_tracepoint
,
6050 sizeof (target_tracepoint
));
6053 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6055 download_agent_expr (tpoint
->cond
));
6057 if (tpoint
->numactions
)
6060 CORE_ADDR actions_array
;
6062 /* The pointers array. */
6064 = target_malloc (sizeof (*tpoint
->actions
) * tpoint
->numactions
);
6065 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6069 /* Now for each pointer, download the action. */
6070 for (i
= 0; i
< tpoint
->numactions
; i
++)
6072 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6073 CORE_ADDR ipa_action
= action
->ops
->download (action
);
6075 if (ipa_action
!= 0)
6076 write_inferior_data_ptr
6077 (actions_array
+ i
* sizeof (*tpoint
->actions
),
6083 #define IPA_PROTO_FAST_TRACE_FLAG 0
6084 #define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
6085 #define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
6086 #define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
6087 #define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
6089 /* Send a command to agent to download and install tracepoint TPOINT. */
6092 tracepoint_send_agent (struct tracepoint
*tpoint
)
6094 char buf
[IPA_CMD_BUF_SIZE
];
6099 strcpy (p
, "FastTrace:");
6102 COPY_FIELD_TO_BUF (p
, tpoint
, number
);
6103 COPY_FIELD_TO_BUF (p
, tpoint
, address
);
6104 COPY_FIELD_TO_BUF (p
, tpoint
, type
);
6105 COPY_FIELD_TO_BUF (p
, tpoint
, enabled
);
6106 COPY_FIELD_TO_BUF (p
, tpoint
, step_count
);
6107 COPY_FIELD_TO_BUF (p
, tpoint
, pass_count
);
6108 COPY_FIELD_TO_BUF (p
, tpoint
, numactions
);
6109 COPY_FIELD_TO_BUF (p
, tpoint
, hit_count
);
6110 COPY_FIELD_TO_BUF (p
, tpoint
, traceframe_usage
);
6111 COPY_FIELD_TO_BUF (p
, tpoint
, compiled_cond
);
6112 COPY_FIELD_TO_BUF (p
, tpoint
, orig_size
);
6115 p
= agent_expr_send (p
, tpoint
->cond
);
6117 /* tracepoint_action */
6118 for (i
= 0; i
< tpoint
->numactions
; i
++)
6120 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6122 p
[0] = action
->type
;
6123 p
= action
->ops
->send (&p
[1], action
);
6126 get_jump_space_head ();
6127 /* Copy the value of GDB_JUMP_PAD_HEAD to command buffer, so that
6128 agent can use jump pad from it. */
6129 if (tpoint
->type
== fast_tracepoint
)
6131 memcpy (p
, &gdb_jump_pad_head
, 8);
6135 ret
= run_inferior_command (buf
, (int) (ptrdiff_t) (p
- buf
));
6139 if (strncmp (buf
, "OK", 2) != 0)
6142 /* The value of tracepoint's target address is stored in BUF. */
6143 memcpy (&tpoint
->obj_addr_on_target
,
6144 &buf
[IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET
], 8);
6146 if (tpoint
->type
== fast_tracepoint
)
6149 = (unsigned char *) &buf
[IPA_PROTO_FAST_TRACE_FJUMP_INSN
];
6152 trace_debug ("agent: read from cmd_buf 0x%x 0x%x\n",
6153 (unsigned int) tpoint
->obj_addr_on_target
,
6154 (unsigned int) gdb_jump_pad_head
);
6156 memcpy (&gdb_jump_pad_head
, &buf
[IPA_PROTO_FAST_TRACE_JUMP_PAD
], 8);
6158 /* This has been done in agent. We should also set up record for it. */
6159 memcpy (&fjump_size
, &buf
[IPA_PROTO_FAST_TRACE_FJUMP_SIZE
], 4);
6162 = set_fast_tracepoint_jump (tpoint
->address
, insn
, fjump_size
);
6169 download_tracepoint (struct tracepoint
*tpoint
)
6171 struct tracepoint
*tp
, *tp_prev
;
6173 if (tpoint
->type
!= fast_tracepoint
6174 && tpoint
->type
!= static_tracepoint
)
6177 download_tracepoint_1 (tpoint
);
6179 /* Find the previous entry of TPOINT, which is fast tracepoint or
6180 static tracepoint. */
6182 for (tp
= tracepoints
; tp
!= tpoint
; tp
= tp
->next
)
6184 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
6190 CORE_ADDR tp_prev_target_next_addr
;
6192 /* Insert TPOINT after TP_PREV in IPA. */
6193 if (read_inferior_data_pointer (tp_prev
->obj_addr_on_target
6194 + offsetof (struct tracepoint
, next
),
6195 &tp_prev_target_next_addr
))
6197 internal_error (__FILE__
, __LINE__
,
6198 "error reading `tp_prev->next'");
6201 /* tpoint->next = tp_prev->next */
6202 write_inferior_data_ptr (tpoint
->obj_addr_on_target
6203 + offsetof (struct tracepoint
, next
),
6204 tp_prev_target_next_addr
);
6205 /* tp_prev->next = tpoint */
6206 write_inferior_data_ptr (tp_prev
->obj_addr_on_target
6207 + offsetof (struct tracepoint
, next
),
6208 tpoint
->obj_addr_on_target
);
6211 /* First object in list, set the head pointer in the
6213 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
,
6214 tpoint
->obj_addr_on_target
);
6219 download_trace_state_variables (void)
6221 CORE_ADDR ptr
= 0, prev_ptr
= 0;
6222 struct trace_state_variable
*tsv
;
6224 /* Start out empty. */
6225 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
, 0);
6227 for (tsv
= trace_state_variables
; tsv
!= NULL
; tsv
= tsv
->next
)
6229 struct trace_state_variable target_tsv
;
6231 /* TSV's with a getter have been initialized equally in both the
6232 inferior and GDBserver. Skip them. */
6233 if (tsv
->getter
!= NULL
)
6239 ptr
= target_malloc (sizeof (*tsv
));
6241 if (tsv
== trace_state_variables
)
6243 /* First object in list, set the head pointer in the
6246 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
,
6251 write_inferior_data_ptr (prev_ptr
6252 + offsetof (struct trace_state_variable
,
6257 /* Write the whole object. We'll fix up its pointers in a bit.
6258 Assume no next, fixup when needed. */
6259 target_tsv
.next
= NULL
;
6261 write_inferior_memory (ptr
, (unsigned char *) &target_tsv
,
6262 sizeof (target_tsv
));
6264 if (tsv
->name
!= NULL
)
6266 size_t size
= strlen (tsv
->name
) + 1;
6267 CORE_ADDR name_addr
= target_malloc (size
);
6268 write_inferior_memory (name_addr
,
6269 (unsigned char *) tsv
->name
, size
);
6270 write_inferior_data_ptr (ptr
6271 + offsetof (struct trace_state_variable
,
6276 gdb_assert (tsv
->getter
== NULL
);
6281 /* Fixup the next pointer in the last item in the list. */
6282 write_inferior_data_ptr (prev_ptr
6283 + offsetof (struct trace_state_variable
,
6288 /* Upload complete trace frames out of the IP Agent's trace buffer
6289 into GDBserver's trace buffer. This always uploads either all or
6290 no trace frames. This is the counter part of
6291 `trace_alloc_trace_buffer'. See its description of the atomic
6292 synching mechanism. */
6295 upload_fast_traceframes (void)
6297 unsigned int ipa_traceframe_read_count
, ipa_traceframe_write_count
;
6298 unsigned int ipa_traceframe_read_count_racy
, ipa_traceframe_write_count_racy
;
6300 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
6301 unsigned int curr_tbctrl_idx
;
6302 unsigned int ipa_trace_buffer_ctrl_curr
;
6303 unsigned int ipa_trace_buffer_ctrl_curr_old
;
6304 CORE_ADDR ipa_trace_buffer_ctrl_addr
;
6305 struct breakpoint
*about_to_request_buffer_space_bkpt
;
6306 CORE_ADDR ipa_trace_buffer_lo
;
6307 CORE_ADDR ipa_trace_buffer_hi
;
6309 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6310 &ipa_traceframe_read_count_racy
))
6312 /* This will happen in most targets if the current thread is
6317 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6318 &ipa_traceframe_write_count_racy
))
6321 trace_debug ("ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6322 ipa_traceframe_write_count_racy
6323 - ipa_traceframe_read_count_racy
,
6324 ipa_traceframe_write_count_racy
,
6325 ipa_traceframe_read_count_racy
);
6327 if (ipa_traceframe_write_count_racy
== ipa_traceframe_read_count_racy
)
6330 about_to_request_buffer_space_bkpt
6331 = set_breakpoint_at (ipa_sym_addrs
.addr_about_to_request_buffer_space
,
6334 if (read_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6335 &ipa_trace_buffer_ctrl_curr
))
6338 ipa_trace_buffer_ctrl_curr_old
= ipa_trace_buffer_ctrl_curr
;
6340 curr_tbctrl_idx
= ipa_trace_buffer_ctrl_curr
& ~GDBSERVER_FLUSH_COUNT_MASK
;
6343 unsigned int prev
, counter
;
6345 /* Update the token, with new counters, and the GDBserver stamp
6346 bit. Alway reuse the current TBC index. */
6347 prev
= ipa_trace_buffer_ctrl_curr
& GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6348 counter
= (prev
+ 0x100) & GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6350 ipa_trace_buffer_ctrl_curr
= (GDBSERVER_UPDATED_FLUSH_COUNT_BIT
6356 if (write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6357 ipa_trace_buffer_ctrl_curr
))
6360 trace_debug ("Lib: Committed %08x -> %08x",
6361 ipa_trace_buffer_ctrl_curr_old
,
6362 ipa_trace_buffer_ctrl_curr
);
6364 /* Re-read these, now that we've installed the
6365 `about_to_request_buffer_space' breakpoint/lock. A thread could
6366 have finished a traceframe between the last read of these
6367 counters and setting the breakpoint above. If we start
6368 uploading, we never want to leave this function with
6369 traceframe_read_count != 0, otherwise, GDBserver could end up
6370 incrementing the counter tokens more than once (due to event loop
6371 nesting), which would break the IP agent's "effective" detection
6372 (see trace_alloc_trace_buffer). */
6373 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6374 &ipa_traceframe_read_count
))
6376 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6377 &ipa_traceframe_write_count
))
6382 trace_debug ("ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6383 ipa_traceframe_write_count
- ipa_traceframe_read_count
,
6384 ipa_traceframe_write_count
, ipa_traceframe_read_count
);
6386 if (ipa_traceframe_write_count
!= ipa_traceframe_write_count_racy
6387 || ipa_traceframe_read_count
!= ipa_traceframe_read_count_racy
)
6388 trace_debug ("note that ipa_traceframe_count's parts changed");
6391 /* Get the address of the current TBC object (the IP agent has an
6392 array of 3 such objects). The index is stored in the TBC
6394 ipa_trace_buffer_ctrl_addr
= ipa_sym_addrs
.addr_trace_buffer_ctrl
;
6395 ipa_trace_buffer_ctrl_addr
6396 += sizeof (struct ipa_trace_buffer_control
) * curr_tbctrl_idx
;
6398 if (read_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6399 (unsigned char *) &ipa_trace_buffer_ctrl
,
6400 sizeof (struct ipa_trace_buffer_control
)))
6403 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
6404 &ipa_trace_buffer_lo
))
6406 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
6407 &ipa_trace_buffer_hi
))
6410 /* Offsets are easier to grok for debugging than raw addresses,
6411 especially for the small trace buffer sizes that are useful for
6413 trace_debug ("Lib: Trace buffer [%d] start=%d free=%d "
6414 "endfree=%d wrap=%d hi=%d",
6416 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6417 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6418 (int) (ipa_trace_buffer_ctrl
.end_free
- ipa_trace_buffer_lo
),
6419 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6420 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6422 /* Note that the IPA's buffer is always circular. */
6424 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6426 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6427 ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6429 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6430 (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6431 - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6432 ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6435 tf
= IPA_FIRST_TRACEFRAME ();
6437 while (ipa_traceframe_write_count
- ipa_traceframe_read_count
)
6439 struct tracepoint
*tpoint
;
6440 struct traceframe
*tframe
;
6441 unsigned char *block
;
6442 struct traceframe ipa_tframe
;
6444 if (read_inferior_memory (tf
, (unsigned char *) &ipa_tframe
,
6445 offsetof (struct traceframe
, data
)))
6446 error ("Uploading: couldn't read traceframe at %s\n", paddress (tf
));
6448 if (ipa_tframe
.tpnum
== 0)
6450 internal_error (__FILE__
, __LINE__
,
6451 "Uploading: No (more) fast traceframes, but"
6452 " ipa_traceframe_count == %u??\n",
6453 ipa_traceframe_write_count
6454 - ipa_traceframe_read_count
);
6457 /* Note that this will be incorrect for multi-location
6459 tpoint
= find_next_tracepoint_by_number (NULL
, ipa_tframe
.tpnum
);
6461 tframe
= add_traceframe (tpoint
);
6464 trace_buffer_is_full
= 1;
6465 trace_debug ("Uploading: trace buffer is full");
6469 /* Copy the whole set of blocks in one go for now. FIXME:
6470 split this in smaller blocks. */
6471 block
= add_traceframe_block (tframe
, tpoint
,
6472 ipa_tframe
.data_size
);
6475 if (read_inferior_memory (tf
6476 + offsetof (struct traceframe
, data
),
6477 block
, ipa_tframe
.data_size
))
6478 error ("Uploading: Couldn't read traceframe data at %s\n",
6479 paddress (tf
+ offsetof (struct traceframe
, data
)));
6482 trace_debug ("Uploading: traceframe didn't fit");
6483 finish_traceframe (tframe
);
6486 tf
= IPA_NEXT_TRACEFRAME (tf
, &ipa_tframe
);
6488 /* If we freed the traceframe that wrapped around, go back
6489 to the non-wrap case. */
6490 if (tf
< ipa_trace_buffer_ctrl
.start
)
6492 trace_debug ("Lib: Discarding past the wraparound");
6493 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6495 ipa_trace_buffer_ctrl
.start
= tf
;
6496 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_ctrl
.start
;
6497 ++ipa_traceframe_read_count
;
6499 if (ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.free
6500 && ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.end_free
)
6502 trace_debug ("Lib: buffer is fully empty. "
6503 "Trace buffer [%d] start=%d free=%d endfree=%d",
6505 (int) (ipa_trace_buffer_ctrl
.start
6506 - ipa_trace_buffer_lo
),
6507 (int) (ipa_trace_buffer_ctrl
.free
6508 - ipa_trace_buffer_lo
),
6509 (int) (ipa_trace_buffer_ctrl
.end_free
6510 - ipa_trace_buffer_lo
));
6512 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
6513 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
6514 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
6515 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6518 trace_debug ("Uploaded a traceframe\n"
6519 "Lib: Trace buffer [%d] start=%d free=%d "
6520 "endfree=%d wrap=%d hi=%d",
6522 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6523 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6524 (int) (ipa_trace_buffer_ctrl
.end_free
6525 - ipa_trace_buffer_lo
),
6526 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6527 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6530 if (write_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6531 (unsigned char *) &ipa_trace_buffer_ctrl
,
6532 sizeof (struct ipa_trace_buffer_control
)))
6535 write_inferior_integer (ipa_sym_addrs
.addr_traceframe_read_count
,
6536 ipa_traceframe_read_count
);
6538 trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx
);
6541 cancel_breakpoints ();
6543 delete_breakpoint (about_to_request_buffer_space_bkpt
);
6544 about_to_request_buffer_space_bkpt
= NULL
;
6548 if (trace_buffer_is_full
)
6553 #ifdef IN_PROCESS_AGENT
6555 IP_AGENT_EXPORT
int ust_loaded
;
6556 IP_AGENT_EXPORT
char cmd_buf
[IPA_CMD_BUF_SIZE
];
6560 /* Static tracepoints. */
6562 /* UST puts a "struct tracepoint" in the global namespace, which
6563 conflicts with our tracepoint. Arguably, being a library, it
6564 shouldn't take ownership of such a generic name. We work around it
6566 #define tracepoint ust_tracepoint
6567 #include <ust/ust.h>
6570 extern int serialize_to_text (char *outbuf
, int bufsize
,
6571 const char *fmt
, va_list ap
);
6573 #define GDB_PROBE_NAME "gdb"
6575 /* We dynamically search for the UST symbols instead of linking them
6576 in. This lets the user decide if the application uses static
6577 tracepoints, instead of always pulling libust.so in. This vector
6578 holds pointers to all functions we care about. */
6582 int (*serialize_to_text
) (char *outbuf
, int bufsize
,
6583 const char *fmt
, va_list ap
);
6585 int (*ltt_probe_register
) (struct ltt_available_probe
*pdata
);
6586 int (*ltt_probe_unregister
) (struct ltt_available_probe
*pdata
);
6588 int (*ltt_marker_connect
) (const char *channel
, const char *mname
,
6590 int (*ltt_marker_disconnect
) (const char *channel
, const char *mname
,
6593 void (*marker_iter_start
) (struct marker_iter
*iter
);
6594 void (*marker_iter_next
) (struct marker_iter
*iter
);
6595 void (*marker_iter_stop
) (struct marker_iter
*iter
);
6596 void (*marker_iter_reset
) (struct marker_iter
*iter
);
6601 /* Cast through typeof to catch incompatible API changes. Since UST
6602 only builds with gcc, we can freely use gcc extensions here
6604 #define GET_UST_SYM(SYM) \
6607 if (ust_ops.SYM == NULL) \
6608 ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6609 if (ust_ops.SYM == NULL) \
6613 #define USTF(SYM) ust_ops.SYM
6615 /* Get pointers to all libust.so functions we care about. */
6620 GET_UST_SYM (serialize_to_text
);
6622 GET_UST_SYM (ltt_probe_register
);
6623 GET_UST_SYM (ltt_probe_unregister
);
6624 GET_UST_SYM (ltt_marker_connect
);
6625 GET_UST_SYM (ltt_marker_disconnect
);
6627 GET_UST_SYM (marker_iter_start
);
6628 GET_UST_SYM (marker_iter_next
);
6629 GET_UST_SYM (marker_iter_stop
);
6630 GET_UST_SYM (marker_iter_reset
);
6636 /* Given an UST marker, return the matching gdb static tracepoint.
6637 The match is done by address. */
6639 static struct tracepoint
*
6640 ust_marker_to_static_tracepoint (const struct marker
*mdata
)
6642 struct tracepoint
*tpoint
;
6644 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
6646 if (tpoint
->type
!= static_tracepoint
)
6649 if (tpoint
->address
== (uintptr_t) mdata
->location
)
6656 /* The probe function we install on lttng/ust markers. Whenever a
6657 probed ust marker is hit, this function is called. This is similar
6658 to gdb_collect, only for static tracepoints, instead of fast
6662 gdb_probe (const struct marker
*mdata
, void *probe_private
,
6663 struct registers
*regs
, void *call_private
,
6664 const char *fmt
, va_list *args
)
6666 struct tracepoint
*tpoint
;
6667 struct static_tracepoint_ctx ctx
;
6669 /* Don't do anything until the trace run is completely set up. */
6672 trace_debug ("gdb_probe: not tracing\n");
6676 ctx
.base
.type
= static_tracepoint
;
6677 ctx
.regcache_initted
= 0;
6682 /* Wrap the regblock in a register cache (in the stack, we don't
6683 want to malloc here). */
6684 ctx
.regspace
= alloca (ipa_tdesc
->registers_size
);
6685 if (ctx
.regspace
== NULL
)
6687 trace_debug ("Trace buffer block allocation failed, skipping");
6691 tpoint
= ust_marker_to_static_tracepoint (mdata
);
6694 trace_debug ("gdb_probe: marker not known: "
6695 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6696 mdata
->location
, mdata
->channel
,
6697 mdata
->name
, mdata
->format
);
6701 if (!tpoint
->enabled
)
6703 trace_debug ("gdb_probe: tracepoint disabled");
6707 ctx
.tpoint
= tpoint
;
6709 trace_debug ("gdb_probe: collecting marker: "
6710 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6711 mdata
->location
, mdata
->channel
,
6712 mdata
->name
, mdata
->format
);
6714 /* Test the condition if present, and collect if true. */
6715 if (tpoint
->cond
== NULL
6716 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6719 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6720 tpoint
->address
, tpoint
);
6722 if (stopping_tracepoint
6723 || trace_buffer_is_full
6724 || expr_eval_result
!= expr_eval_no_error
)
6729 /* If there was a condition and it evaluated to false, the only
6730 way we would stop tracing is if there was an error during
6731 condition expression evaluation. */
6732 if (expr_eval_result
!= expr_eval_no_error
)
6737 /* Called if the gdb static tracepoint requested collecting "$_sdata",
6738 static tracepoint string data. This is a string passed to the
6739 tracing library by the user, at the time of the tracepoint marker
6740 call. E.g., in the UST marker call:
6742 trace_mark (ust, bar33, "str %s", "FOOBAZ");
6744 the collected data is "str FOOBAZ".
6748 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
6749 struct traceframe
*tframe
)
6751 struct static_tracepoint_ctx
*umd
= (struct static_tracepoint_ctx
*) ctx
;
6752 unsigned char *bufspace
;
6755 unsigned short blocklen
;
6759 trace_debug ("Wanted to collect static trace data, "
6760 "but there's no static trace data");
6764 va_copy (copy
, *umd
->args
);
6765 size
= USTF(serialize_to_text
) (NULL
, 0, umd
->fmt
, copy
);
6768 trace_debug ("Want to collect ust data");
6770 /* 'S' + size + string */
6771 bufspace
= add_traceframe_block (tframe
, umd
->tpoint
,
6772 1 + sizeof (blocklen
) + size
+ 1);
6773 if (bufspace
== NULL
)
6775 trace_debug ("Trace buffer block allocation failed, skipping");
6779 /* Identify a static trace data block. */
6782 blocklen
= size
+ 1;
6783 memcpy (bufspace
+ 1, &blocklen
, sizeof (blocklen
));
6785 va_copy (copy
, *umd
->args
);
6786 USTF(serialize_to_text
) ((char *) bufspace
+ 1 + sizeof (blocklen
),
6787 size
+ 1, umd
->fmt
, copy
);
6790 trace_debug ("Storing static tracepoint data in regblock: %s",
6791 bufspace
+ 1 + sizeof (blocklen
));
6794 /* The probe to register with lttng/ust. */
6795 static struct ltt_available_probe gdb_ust_probe
=
6802 #endif /* HAVE_UST */
6803 #endif /* IN_PROCESS_AGENT */
6805 #ifndef IN_PROCESS_AGENT
6807 /* Ask the in-process agent to run a command. Since we don't want to
6808 have to handle the IPA hitting breakpoints while running the
6809 command, we pause all threads, remove all breakpoints, and then set
6810 the helper thread re-running. We communicate with the helper
6811 thread by means of direct memory xfering, and a socket for
6815 run_inferior_command (char *cmd
, int len
)
6818 int pid
= ptid_get_pid (current_ptid
);
6820 trace_debug ("run_inferior_command: running: %s", cmd
);
6823 uninsert_all_breakpoints ();
6825 err
= agent_run_command (pid
, (const char *) cmd
, len
);
6827 reinsert_all_breakpoints ();
6833 #else /* !IN_PROCESS_AGENT */
6835 #include <sys/socket.h>
6838 #ifndef UNIX_PATH_MAX
6839 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6842 /* Where we put the socked used for synchronization. */
6843 #define SOCK_DIR P_tmpdir
6845 /* Thread ID of the helper thread. GDBserver reads this to know which
6846 is the help thread. This is an LWP id on Linux. */
6847 int helper_thread_id
;
6850 init_named_socket (const char *name
)
6853 struct sockaddr_un addr
;
6855 result
= fd
= socket (PF_UNIX
, SOCK_STREAM
, 0);
6858 warning ("socket creation failed: %s", strerror (errno
));
6862 addr
.sun_family
= AF_UNIX
;
6864 strncpy (addr
.sun_path
, name
, UNIX_PATH_MAX
);
6865 addr
.sun_path
[UNIX_PATH_MAX
- 1] = '\0';
6867 result
= access (name
, F_OK
);
6871 result
= unlink (name
);
6874 warning ("unlink failed: %s", strerror (errno
));
6878 warning ("socket %s already exists; overwriting", name
);
6881 result
= bind (fd
, (struct sockaddr
*) &addr
, sizeof (addr
));
6884 warning ("bind failed: %s", strerror (errno
));
6889 result
= listen (fd
, 1);
6892 warning ("listen: %s", strerror (errno
));
6900 static char agent_socket_name
[UNIX_PATH_MAX
];
6903 gdb_agent_socket_init (void)
6907 result
= xsnprintf (agent_socket_name
, UNIX_PATH_MAX
, "%s/gdb_ust%d",
6908 SOCK_DIR
, getpid ());
6909 if (result
>= UNIX_PATH_MAX
)
6911 trace_debug ("string overflow allocating socket name");
6915 fd
= init_named_socket (agent_socket_name
);
6917 warning ("Error initializing named socket (%s) for communication with the "
6918 "ust helper thread. Check that directory exists and that it "
6919 "is writable.", agent_socket_name
);
6926 /* The next marker to be returned on a qTsSTM command. */
6927 static const struct marker
*next_st
;
6929 /* Returns the first known marker. */
6934 struct marker_iter iter
;
6936 USTF(marker_iter_reset
) (&iter
);
6937 USTF(marker_iter_start
) (&iter
);
6942 /* Returns the marker following M. */
6944 const struct marker
*
6945 next_marker (const struct marker
*m
)
6947 struct marker_iter iter
;
6949 USTF(marker_iter_reset
) (&iter
);
6950 USTF(marker_iter_start
) (&iter
);
6952 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
6954 if (iter
.marker
== m
)
6956 USTF(marker_iter_next
) (&iter
);
6964 /* Return an hexstr version of the STR C string, fit for sending to
6968 cstr_to_hexstr (const char *str
)
6970 int len
= strlen (str
);
6971 char *hexstr
= xmalloc (len
* 2 + 1);
6972 bin2hex ((gdb_byte
*) str
, hexstr
, len
);
6976 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
6980 response_ust_marker (char *packet
, const struct marker
*st
)
6982 char *strid
, *format
, *tmp
;
6984 next_st
= next_marker (st
);
6986 tmp
= xmalloc (strlen (st
->channel
) + 1 +
6987 strlen (st
->name
) + 1);
6988 sprintf (tmp
, "%s/%s", st
->channel
, st
->name
);
6990 strid
= cstr_to_hexstr (tmp
);
6993 format
= cstr_to_hexstr (st
->format
);
6995 sprintf (packet
, "m%s:%s:%s",
6996 paddress ((uintptr_t) st
->location
),
7004 /* Return the first static tracepoint, and initialize the state
7005 machine that will iterate through all the static tracepoints. */
7008 cmd_qtfstm (char *packet
)
7010 trace_debug ("Returning first trace state variable definition");
7012 if (first_marker ())
7013 response_ust_marker (packet
, first_marker ());
7015 strcpy (packet
, "l");
7018 /* Return additional trace state variable definitions. */
7021 cmd_qtsstm (char *packet
)
7023 trace_debug ("Returning static tracepoint");
7026 response_ust_marker (packet
, next_st
);
7028 strcpy (packet
, "l");
7031 /* Disconnect the GDB probe from a marker at a given address. */
7034 unprobe_marker_at (char *packet
)
7038 struct marker_iter iter
;
7040 p
+= sizeof ("unprobe_marker_at:") - 1;
7042 p
= unpack_varlen_hex (p
, &address
);
7044 USTF(marker_iter_reset
) (&iter
);
7045 USTF(marker_iter_start
) (&iter
);
7046 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
7047 if ((uintptr_t ) iter
.marker
->location
== address
)
7051 result
= USTF(ltt_marker_disconnect
) (iter
.marker
->channel
,
7055 warning ("could not disable marker %s/%s",
7056 iter
.marker
->channel
, iter
.marker
->name
);
7061 /* Connect the GDB probe to a marker at a given address. */
7064 probe_marker_at (char *packet
)
7068 struct marker_iter iter
;
7071 p
+= sizeof ("probe_marker_at:") - 1;
7073 p
= unpack_varlen_hex (p
, &address
);
7075 USTF(marker_iter_reset
) (&iter
);
7077 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7079 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7080 if ((uintptr_t ) m
->location
== address
)
7084 trace_debug ("found marker for address. "
7085 "ltt_marker_connect (marker = %s/%s)",
7086 m
->channel
, m
->name
);
7088 result
= USTF(ltt_marker_connect
) (m
->channel
, m
->name
,
7090 if (result
&& result
!= -EEXIST
)
7091 trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
7092 m
->channel
, m
->name
, -result
);
7096 sprintf (packet
, "E.could not connect marker: channel=%s, name=%s",
7097 m
->channel
, m
->name
);
7101 strcpy (packet
, "OK");
7105 sprintf (packet
, "E.no marker found at 0x%s", paddress (address
));
7110 cmd_qtstmat (char *packet
)
7114 struct marker_iter iter
;
7117 p
+= sizeof ("qTSTMat:") - 1;
7119 p
= unpack_varlen_hex (p
, &address
);
7121 USTF(marker_iter_reset
) (&iter
);
7123 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7125 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7126 if ((uintptr_t ) m
->location
== address
)
7128 response_ust_marker (packet
, m
);
7132 strcpy (packet
, "l");
7142 USTF(ltt_probe_register
) (&gdb_ust_probe
);
7145 #endif /* HAVE_UST */
7147 #include <sys/syscall.h>
7150 gdb_agent_remove_socket (void)
7152 unlink (agent_socket_name
);
7155 /* Helper thread of agent. */
7158 gdb_agent_helper_thread (void *arg
)
7162 atexit (gdb_agent_remove_socket
);
7166 listen_fd
= gdb_agent_socket_init ();
7168 if (helper_thread_id
== 0)
7169 helper_thread_id
= syscall (SYS_gettid
);
7171 if (listen_fd
== -1)
7173 warning ("could not create sync socket\n");
7180 struct sockaddr_un sockaddr
;
7186 tmp
= sizeof (sockaddr
);
7190 fd
= accept (listen_fd
, &sockaddr
, &tmp
);
7192 /* It seems an ERESTARTSYS can escape out of accept. */
7193 while (fd
== -512 || (fd
== -1 && errno
== EINTR
));
7197 warning ("Accept returned %d, error: %s\n",
7198 fd
, strerror (errno
));
7204 ret
= read (fd
, buf
, 1);
7205 } while (ret
== -1 && errno
== EINTR
);
7209 warning ("reading socket (fd=%d) failed with %s",
7210 fd
, strerror (errno
));
7217 if (strncmp ("close", cmd_buf
, 5) == 0)
7222 else if (strcmp ("qTfSTM", cmd_buf
) == 0)
7224 cmd_qtfstm (cmd_buf
);
7226 else if (strcmp ("qTsSTM", cmd_buf
) == 0)
7228 cmd_qtsstm (cmd_buf
);
7230 else if (strncmp ("unprobe_marker_at:",
7232 sizeof ("unprobe_marker_at:") - 1) == 0)
7234 unprobe_marker_at (cmd_buf
);
7236 else if (strncmp ("probe_marker_at:",
7238 sizeof ("probe_marker_at:") - 1) == 0)
7240 probe_marker_at (cmd_buf
);
7242 else if (strncmp ("qTSTMat:",
7244 sizeof ("qTSTMat:") - 1) == 0)
7246 cmd_qtstmat (cmd_buf
);
7248 #endif /* HAVE_UST */
7251 /* Fix compiler's warning: ignoring return value of 'write'. */
7252 ret
= write (fd
, buf
, 1);
7258 unlink (agent_socket_name
);
7260 /* Sleep endlessly to wait the whole inferior stops. This
7261 thread can not exit because GDB or GDBserver may still need
7262 'current_inferior' (representing this thread) to access
7263 inferior memory. Otherwise, this thread exits earlier than
7264 other threads, and 'current_inferior' is set to NULL. */
7275 #include <pthread.h>
7277 IP_AGENT_EXPORT
int gdb_agent_capability
= AGENT_CAPA_STATIC_TRACE
;
7280 gdb_agent_init (void)
7287 /* We want the helper thread to be as transparent as possible, so
7288 have it inherit an all-signals-blocked mask. */
7290 sigfillset (&new_mask
);
7291 res
= pthread_sigmask (SIG_SETMASK
, &new_mask
, &orig_mask
);
7293 perror_with_name ("pthread_sigmask (1)");
7295 res
= pthread_create (&thread
,
7297 gdb_agent_helper_thread
,
7300 res
= pthread_sigmask (SIG_SETMASK
, &orig_mask
, NULL
);
7302 perror_with_name ("pthread_sigmask (2)");
7304 while (helper_thread_id
== 0)
7312 #include <sys/mman.h>
7315 IP_AGENT_EXPORT
char *gdb_tp_heap_buffer
;
7316 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer
;
7317 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer_end
;
7318 IP_AGENT_EXPORT
char *gdb_trampoline_buffer
;
7319 IP_AGENT_EXPORT
char *gdb_trampoline_buffer_end
;
7320 IP_AGENT_EXPORT
char *gdb_trampoline_buffer_error
;
7322 /* Record the result of getting buffer space for fast tracepoint
7323 trampolines. Any error message is copied, since caller may not be
7324 using persistent storage. */
7327 set_trampoline_buffer_space (CORE_ADDR begin
, CORE_ADDR end
, char *errmsg
)
7329 gdb_trampoline_buffer
= (char *) (uintptr_t) begin
;
7330 gdb_trampoline_buffer_end
= (char *) (uintptr_t) end
;
7332 strncpy (gdb_trampoline_buffer_error
, errmsg
, 99);
7334 strcpy (gdb_trampoline_buffer_error
, "no buffer passed");
7337 static void __attribute__ ((constructor
))
7338 initialize_tracepoint_ftlib (void)
7340 initialize_tracepoint ();
7345 #endif /* IN_PROCESS_AGENT */
7347 /* Return a timestamp, expressed as microseconds of the usual Unix
7348 time. (As the result is a 64-bit number, it will not overflow any
7352 get_timestamp (void)
7356 if (gettimeofday (&tv
, 0) != 0)
7359 return (LONGEST
) tv
.tv_sec
* 1000000 + tv
.tv_usec
;
7363 initialize_tracepoint (void)
7365 /* Start with the default size. */
7366 init_trace_buffer (DEFAULT_TRACE_BUFFER_SIZE
);
7368 /* Wire trace state variable 1 to be the timestamp. This will be
7369 uploaded to GDB upon connection and become one of its trace state
7370 variables. (In case you're wondering, if GDB already has a trace
7371 variable numbered 1, it will be renumbered.) */
7372 create_trace_state_variable (1, 0);
7373 set_trace_state_variable_name (1, "trace_timestamp");
7374 set_trace_state_variable_getter (1, get_timestamp
);
7376 #ifdef IN_PROCESS_AGENT
7381 pagesize
= sysconf (_SC_PAGE_SIZE
);
7383 perror_with_name ("sysconf");
7385 gdb_tp_heap_buffer
= xmalloc (5 * 1024 * 1024);
7387 #define SCRATCH_BUFFER_NPAGES 20
7389 /* Allocate scratch buffer aligned on a page boundary, at a low
7390 address (close to the main executable's code). */
7391 for (addr
= pagesize
; addr
!= 0; addr
+= pagesize
)
7393 gdb_jump_pad_buffer
= mmap ((void *) addr
, pagesize
* SCRATCH_BUFFER_NPAGES
,
7394 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
7395 MAP_PRIVATE
| MAP_ANONYMOUS
| MAP_FIXED
,
7397 if (gdb_jump_pad_buffer
!= MAP_FAILED
)
7402 perror_with_name ("mmap");
7404 gdb_jump_pad_buffer_end
= gdb_jump_pad_buffer
+ pagesize
* SCRATCH_BUFFER_NPAGES
;
7407 gdb_trampoline_buffer
= gdb_trampoline_buffer_end
= 0;
7409 /* It's not a fatal error for something to go wrong with trampoline
7410 buffer setup, but it can be mysterious, so create a channel to
7411 report back on what went wrong, using a fixed size since we may
7412 not be able to allocate space later when the problem occurs. */
7413 gdb_trampoline_buffer_error
= xmalloc (IPA_BUFSIZ
);
7415 strcpy (gdb_trampoline_buffer_error
, "No errors reported");
7417 initialize_low_tracepoint ();