1 /* Tracepoint code for remote server for GDB.
2 Copyright (C) 2009-2013 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 "gdbthread.h"
33 /* This file is built for both GDBserver, and the in-process
34 agent (IPA), a shared library that includes a tracing agent that is
35 loaded by the inferior to support fast tracepoints. Fast
36 tracepoints (or more accurately, jump based tracepoints) are
37 implemented by patching the tracepoint location with a jump into a
38 small trampoline function whose job is to save the register state,
39 call the in-process tracing agent, and then execute the original
40 instruction that was under the tracepoint jump (possibly adjusted,
41 if PC-relative, or some such).
43 The current synchronization design is pull based. That means,
44 GDBserver does most of the work, by peeking/poking at the inferior
45 agent's memory directly for downloading tracepoint and associated
46 objects, and for uploading trace frames. Whenever the IPA needs
47 something from GDBserver (trace buffer is full, tracing stopped for
48 some reason, etc.) the IPA calls a corresponding hook function
49 where GDBserver has placed a breakpoint.
51 Each of the agents has its own trace buffer. When browsing the
52 trace frames built from slow and fast tracepoints from GDB (tfind
53 mode), there's no guarantee the user is seeing the trace frames in
54 strict chronological creation order, although, GDBserver tries to
55 keep the order relatively reasonable, by syncing the trace buffers
60 static void trace_vdebug (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
63 trace_vdebug (const char *fmt
, ...)
69 vsprintf (buf
, fmt
, ap
);
70 fprintf (stderr
, PROG
"/tracepoint: %s\n", buf
);
74 #define trace_debug_1(level, fmt, args...) \
76 if (level <= debug_threads) \
77 trace_vdebug ((fmt), ##args); \
80 #define trace_debug(FMT, args...) \
81 trace_debug_1 (1, FMT, ##args)
84 # define ATTR_USED __attribute__((used))
85 # define ATTR_NOINLINE __attribute__((noinline))
86 # define ATTR_CONSTRUCTOR __attribute__ ((constructor))
89 # define ATTR_NOINLINE
90 # define ATTR_CONSTRUCTOR
93 /* Make sure the functions the IPA needs to export (symbols GDBserver
94 needs to query GDB about) are exported. */
96 #ifdef IN_PROCESS_AGENT
97 # if defined _WIN32 || defined __CYGWIN__
98 # define IP_AGENT_EXPORT __declspec(dllexport) ATTR_USED
101 # define IP_AGENT_EXPORT \
102 __attribute__ ((visibility("default"))) ATTR_USED
104 # define IP_AGENT_EXPORT ATTR_USED
108 # define IP_AGENT_EXPORT
111 /* Prefix exported symbols, for good citizenship. All the symbols
112 that need exporting are defined in this module. */
113 #ifdef IN_PROCESS_AGENT
114 # define gdb_tp_heap_buffer gdb_agent_gdb_tp_heap_buffer
115 # define gdb_jump_pad_buffer gdb_agent_gdb_jump_pad_buffer
116 # define gdb_jump_pad_buffer_end gdb_agent_gdb_jump_pad_buffer_end
117 # define gdb_trampoline_buffer gdb_agent_gdb_trampoline_buffer
118 # define gdb_trampoline_buffer_end gdb_agent_gdb_trampoline_buffer_end
119 # define gdb_trampoline_buffer_error gdb_agent_gdb_trampoline_buffer_error
120 # define collecting gdb_agent_collecting
121 # define gdb_collect gdb_agent_gdb_collect
122 # define stop_tracing gdb_agent_stop_tracing
123 # define flush_trace_buffer gdb_agent_flush_trace_buffer
124 # define about_to_request_buffer_space gdb_agent_about_to_request_buffer_space
125 # define trace_buffer_is_full gdb_agent_trace_buffer_is_full
126 # define stopping_tracepoint gdb_agent_stopping_tracepoint
127 # define expr_eval_result gdb_agent_expr_eval_result
128 # define error_tracepoint gdb_agent_error_tracepoint
129 # define tracepoints gdb_agent_tracepoints
130 # define tracing gdb_agent_tracing
131 # define trace_buffer_ctrl gdb_agent_trace_buffer_ctrl
132 # define trace_buffer_ctrl_curr gdb_agent_trace_buffer_ctrl_curr
133 # define trace_buffer_lo gdb_agent_trace_buffer_lo
134 # define trace_buffer_hi gdb_agent_trace_buffer_hi
135 # define traceframe_read_count gdb_agent_traceframe_read_count
136 # define traceframe_write_count gdb_agent_traceframe_write_count
137 # define traceframes_created gdb_agent_traceframes_created
138 # define trace_state_variables gdb_agent_trace_state_variables
139 # define get_raw_reg gdb_agent_get_raw_reg
140 # define get_trace_state_variable_value \
141 gdb_agent_get_trace_state_variable_value
142 # define set_trace_state_variable_value \
143 gdb_agent_set_trace_state_variable_value
144 # define ust_loaded gdb_agent_ust_loaded
145 # define helper_thread_id gdb_agent_helper_thread_id
146 # define cmd_buf gdb_agent_cmd_buf
149 #ifndef IN_PROCESS_AGENT
151 /* Addresses of in-process agent's symbols GDBserver cares about. */
153 struct ipa_sym_addresses
155 CORE_ADDR addr_gdb_tp_heap_buffer
;
156 CORE_ADDR addr_gdb_jump_pad_buffer
;
157 CORE_ADDR addr_gdb_jump_pad_buffer_end
;
158 CORE_ADDR addr_gdb_trampoline_buffer
;
159 CORE_ADDR addr_gdb_trampoline_buffer_end
;
160 CORE_ADDR addr_gdb_trampoline_buffer_error
;
161 CORE_ADDR addr_collecting
;
162 CORE_ADDR addr_gdb_collect
;
163 CORE_ADDR addr_stop_tracing
;
164 CORE_ADDR addr_flush_trace_buffer
;
165 CORE_ADDR addr_about_to_request_buffer_space
;
166 CORE_ADDR addr_trace_buffer_is_full
;
167 CORE_ADDR addr_stopping_tracepoint
;
168 CORE_ADDR addr_expr_eval_result
;
169 CORE_ADDR addr_error_tracepoint
;
170 CORE_ADDR addr_tracepoints
;
171 CORE_ADDR addr_tracing
;
172 CORE_ADDR addr_trace_buffer_ctrl
;
173 CORE_ADDR addr_trace_buffer_ctrl_curr
;
174 CORE_ADDR addr_trace_buffer_lo
;
175 CORE_ADDR addr_trace_buffer_hi
;
176 CORE_ADDR addr_traceframe_read_count
;
177 CORE_ADDR addr_traceframe_write_count
;
178 CORE_ADDR addr_traceframes_created
;
179 CORE_ADDR addr_trace_state_variables
;
180 CORE_ADDR addr_get_raw_reg
;
181 CORE_ADDR addr_get_trace_state_variable_value
;
182 CORE_ADDR addr_set_trace_state_variable_value
;
183 CORE_ADDR addr_ust_loaded
;
192 IPA_SYM(gdb_tp_heap_buffer
),
193 IPA_SYM(gdb_jump_pad_buffer
),
194 IPA_SYM(gdb_jump_pad_buffer_end
),
195 IPA_SYM(gdb_trampoline_buffer
),
196 IPA_SYM(gdb_trampoline_buffer_end
),
197 IPA_SYM(gdb_trampoline_buffer_error
),
199 IPA_SYM(gdb_collect
),
200 IPA_SYM(stop_tracing
),
201 IPA_SYM(flush_trace_buffer
),
202 IPA_SYM(about_to_request_buffer_space
),
203 IPA_SYM(trace_buffer_is_full
),
204 IPA_SYM(stopping_tracepoint
),
205 IPA_SYM(expr_eval_result
),
206 IPA_SYM(error_tracepoint
),
207 IPA_SYM(tracepoints
),
209 IPA_SYM(trace_buffer_ctrl
),
210 IPA_SYM(trace_buffer_ctrl_curr
),
211 IPA_SYM(trace_buffer_lo
),
212 IPA_SYM(trace_buffer_hi
),
213 IPA_SYM(traceframe_read_count
),
214 IPA_SYM(traceframe_write_count
),
215 IPA_SYM(traceframes_created
),
216 IPA_SYM(trace_state_variables
),
217 IPA_SYM(get_raw_reg
),
218 IPA_SYM(get_trace_state_variable_value
),
219 IPA_SYM(set_trace_state_variable_value
),
223 static struct ipa_sym_addresses ipa_sym_addrs
;
225 static int read_inferior_integer (CORE_ADDR symaddr
, int *val
);
227 /* Returns true if both the in-process agent library and the static
228 tracepoints libraries are loaded in the inferior, and agent has
229 capability on static tracepoints. */
232 in_process_agent_supports_ust (void)
236 if (!agent_loaded_p ())
238 warning ("In-process agent not loaded");
242 if (agent_capability_check (AGENT_CAPA_STATIC_TRACE
))
244 /* Agent understands static tracepoint, then check whether UST is in
245 fact loaded in the inferior. */
246 if (read_inferior_integer (ipa_sym_addrs
.addr_ust_loaded
, &loaded
))
248 warning ("Error reading ust_loaded in lib");
259 write_e_ipa_not_loaded (char *buffer
)
262 "E.In-process agent library not loaded in process. "
263 "Fast and static tracepoints unavailable.");
266 /* Write an error to BUFFER indicating that UST isn't loaded in the
270 write_e_ust_not_loaded (char *buffer
)
274 "E.UST library not loaded in process. "
275 "Static tracepoints unavailable.");
277 sprintf (buffer
, "E.GDBserver was built without static tracepoints support");
281 /* If the in-process agent library isn't loaded in the inferior, write
282 an error to BUFFER, and return 1. Otherwise, return 0. */
285 maybe_write_ipa_not_loaded (char *buffer
)
287 if (!agent_loaded_p ())
289 write_e_ipa_not_loaded (buffer
);
295 /* If the in-process agent library and the ust (static tracepoints)
296 library aren't loaded in the inferior, write an error to BUFFER,
297 and return 1. Otherwise, return 0. */
300 maybe_write_ipa_ust_not_loaded (char *buffer
)
302 if (!agent_loaded_p ())
304 write_e_ipa_not_loaded (buffer
);
307 else if (!in_process_agent_supports_ust ())
309 write_e_ust_not_loaded (buffer
);
315 /* Cache all future symbols that the tracepoints module might request.
316 We can not request symbols at arbitrary states in the remote
317 protocol, only when the client tells us that new symbols are
318 available. So when we load the in-process library, make sure to
319 check the entire list. */
322 tracepoint_look_up_symbols (void)
326 if (agent_loaded_p ())
329 for (i
= 0; i
< sizeof (symbol_list
) / sizeof (symbol_list
[0]); i
++)
332 (CORE_ADDR
*) ((char *) &ipa_sym_addrs
+ symbol_list
[i
].offset
);
334 if (look_up_one_symbol (symbol_list
[i
].name
, addrp
, 1) == 0)
337 fprintf (stderr
, "symbol `%s' not found\n", symbol_list
[i
].name
);
342 agent_look_up_symbols (NULL
);
347 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
348 of the "stop_tracing" function. When this breakpoint is hit,
349 tracing stopped in the IPA for some reason. E.g., due to
350 tracepoint reaching the pass count, hitting conditional expression
351 evaluation error, etc.
353 The IPA's trace buffer is never in circular tracing mode: instead,
354 GDBserver's is, and whenever the in-process buffer fills, it calls
355 "flush_trace_buffer", which triggers an internal breakpoint.
356 GDBserver reacts to this breakpoint by pulling the meanwhile
357 collected data. Old frames discarding is always handled on the
360 #ifdef IN_PROCESS_AGENT
362 read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
364 memcpy (myaddr
, (void *) (uintptr_t) memaddr
, len
);
368 /* Call this in the functions where GDBserver places a breakpoint, so
369 that the compiler doesn't try to be clever and skip calling the
370 function at all. This is necessary, even if we tell the compiler
371 to not inline said functions. */
373 #if defined(__GNUC__)
374 # define UNKNOWN_SIDE_EFFECTS() asm ("")
376 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
379 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
382 /* GDBserver places breakpoint here. */
383 UNKNOWN_SIDE_EFFECTS();
386 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
387 flush_trace_buffer (void)
389 /* GDBserver places breakpoint here. */
390 UNKNOWN_SIDE_EFFECTS();
395 #ifndef IN_PROCESS_AGENT
397 tracepoint_handler (CORE_ADDR address
)
399 trace_debug ("tracepoint_handler: tracepoint at 0x%s hit",
404 /* Breakpoint at "stop_tracing" in the inferior lib. */
405 struct breakpoint
*stop_tracing_bkpt
;
406 static int stop_tracing_handler (CORE_ADDR
);
408 /* Breakpoint at "flush_trace_buffer" in the inferior lib. */
409 struct breakpoint
*flush_trace_buffer_bkpt
;
410 static int flush_trace_buffer_handler (CORE_ADDR
);
412 static void download_trace_state_variables (void);
413 static void upload_fast_traceframes (void);
415 static int run_inferior_command (char *cmd
, int len
);
418 read_inferior_integer (CORE_ADDR symaddr
, int *val
)
420 return read_inferior_memory (symaddr
, (unsigned char *) val
,
425 static int tracepoint_send_agent (struct tracepoint
*tpoint
);
428 read_inferior_uinteger (CORE_ADDR symaddr
, unsigned int *val
)
430 return read_inferior_memory (symaddr
, (unsigned char *) val
,
435 read_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR
*val
)
437 void *pval
= (void *) (uintptr_t) val
;
440 ret
= read_inferior_memory (symaddr
, (unsigned char *) &pval
, sizeof (pval
));
441 *val
= (uintptr_t) pval
;
446 write_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR val
)
448 void *pval
= (void *) (uintptr_t) val
;
449 return write_inferior_memory (symaddr
,
450 (unsigned char *) &pval
, sizeof (pval
));
454 write_inferior_integer (CORE_ADDR symaddr
, int val
)
456 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
460 write_inferior_uinteger (CORE_ADDR symaddr
, unsigned int val
)
462 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
465 static CORE_ADDR
target_malloc (ULONGEST size
);
466 static int write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
);
468 #define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
470 memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
471 BUF += sizeof ((OBJ)->FIELD); \
476 /* Operations on various types of tracepoint actions. */
478 struct tracepoint_action
;
480 struct tracepoint_action_ops
482 /* Download tracepoint action ACTION to IPA. Return the address of action
484 CORE_ADDR (*download
) (const struct tracepoint_action
*action
);
486 /* Send ACTION to agent via command buffer started from BUFFER. Return
487 updated head of command buffer. */
488 char* (*send
) (char *buffer
, const struct tracepoint_action
*action
);
491 /* Base action. Concrete actions inherit this. */
493 struct tracepoint_action
495 #ifndef IN_PROCESS_AGENT
496 const struct tracepoint_action_ops
*ops
;
501 /* An 'M' (collect memory) action. */
502 struct collect_memory_action
504 struct tracepoint_action base
;
511 /* An 'R' (collect registers) action. */
513 struct collect_registers_action
515 struct tracepoint_action base
;
518 /* An 'X' (evaluate expression) action. */
520 struct eval_expr_action
522 struct tracepoint_action base
;
524 struct agent_expr
*expr
;
527 /* An 'L' (collect static trace data) action. */
528 struct collect_static_trace_data_action
530 struct tracepoint_action base
;
533 #ifndef IN_PROCESS_AGENT
535 m_tracepoint_action_download (const struct tracepoint_action
*action
)
537 int size_in_ipa
= (sizeof (struct collect_memory_action
)
538 - offsetof (struct tracepoint_action
, type
));
539 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
541 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
547 m_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
549 struct collect_memory_action
*maction
550 = (struct collect_memory_action
*) action
;
552 COPY_FIELD_TO_BUF (buffer
, maction
, addr
);
553 COPY_FIELD_TO_BUF (buffer
, maction
, len
);
554 COPY_FIELD_TO_BUF (buffer
, maction
, basereg
);
559 static const struct tracepoint_action_ops m_tracepoint_action_ops
=
561 m_tracepoint_action_download
,
562 m_tracepoint_action_send
,
566 r_tracepoint_action_download (const struct tracepoint_action
*action
)
568 int size_in_ipa
= (sizeof (struct collect_registers_action
)
569 - offsetof (struct tracepoint_action
, type
));
570 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
572 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
579 r_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
584 static const struct tracepoint_action_ops r_tracepoint_action_ops
=
586 r_tracepoint_action_download
,
587 r_tracepoint_action_send
,
590 static CORE_ADDR
download_agent_expr (struct agent_expr
*expr
);
593 x_tracepoint_action_download (const struct tracepoint_action
*action
)
595 int size_in_ipa
= (sizeof (struct eval_expr_action
)
596 - offsetof (struct tracepoint_action
, type
));
597 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
600 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
602 expr
= download_agent_expr (((struct eval_expr_action
*)action
)->expr
);
603 write_inferior_data_ptr (ipa_action
+ offsetof (struct eval_expr_action
, expr
)
604 - offsetof (struct tracepoint_action
, type
),
610 /* Copy agent expression AEXPR to buffer pointed by P. If AEXPR is NULL,
611 copy 0 to P. Return updated header of buffer. */
614 agent_expr_send (char *p
, const struct agent_expr
*aexpr
)
616 /* Copy the length of condition first, and then copy its
625 memcpy (p
, &aexpr
->length
, 4);
628 memcpy (p
, aexpr
->bytes
, aexpr
->length
);
635 x_tracepoint_action_send ( char *buffer
, const struct tracepoint_action
*action
)
637 struct eval_expr_action
*eaction
= (struct eval_expr_action
*) action
;
639 return agent_expr_send (buffer
, eaction
->expr
);
642 static const struct tracepoint_action_ops x_tracepoint_action_ops
=
644 x_tracepoint_action_download
,
645 x_tracepoint_action_send
,
649 l_tracepoint_action_download (const struct tracepoint_action
*action
)
651 int size_in_ipa
= (sizeof (struct collect_static_trace_data_action
)
652 - offsetof (struct tracepoint_action
, type
));
653 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
655 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
662 l_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
667 static const struct tracepoint_action_ops l_tracepoint_action_ops
=
669 l_tracepoint_action_download
,
670 l_tracepoint_action_send
,
674 /* This structure describes a piece of the source-level definition of
675 the tracepoint. The contents are not interpreted by the target,
676 but preserved verbatim for uploading upon reconnection. */
680 /* The type of string, such as "cond" for a conditional. */
683 /* The source-level string itself. For the sake of target
684 debugging, we store it in plaintext, even though it is always
685 transmitted in hex. */
688 /* Link to the next one in the list. We link them in the order
689 received, in case some make up an ordered list of commands or
691 struct source_string
*next
;
696 /* Trap based tracepoint. */
699 /* A fast tracepoint implemented with a jump instead of a trap. */
702 /* A static tracepoint, implemented by a program call into a tracing
707 struct tracepoint_hit_ctx
;
709 typedef enum eval_result_type (*condfn
) (struct tracepoint_hit_ctx
*,
712 /* The definition of a tracepoint. */
714 /* Tracepoints may have multiple locations, each at a different
715 address. This can occur with optimizations, template
716 instantiation, etc. Since the locations may be in different
717 scopes, the conditions and actions may be different for each
718 location. Our target version of tracepoints is more like GDB's
719 notion of "breakpoint locations", but we have almost nothing that
720 is not per-location, so we bother having two kinds of objects. The
721 key consequence is that numbers are not unique, and that it takes
722 both number and address to identify a tracepoint uniquely. */
726 /* The number of the tracepoint, as specified by GDB. Several
727 tracepoint objects here may share a number. */
730 /* Address at which the tracepoint is supposed to trigger. Several
731 tracepoints may share an address. */
734 /* Tracepoint type. */
735 enum tracepoint_type type
;
737 /* True if the tracepoint is currently enabled. */
740 /* The number of single steps that will be performed after each
744 /* The number of times the tracepoint may be hit before it will
745 terminate the entire tracing run. */
748 /* Pointer to the agent expression that is the tracepoint's
749 conditional, or NULL if the tracepoint is unconditional. */
750 struct agent_expr
*cond
;
752 /* The list of actions to take when the tracepoint triggers. */
754 struct tracepoint_action
**actions
;
756 /* Count of the times we've hit this tracepoint during the run.
757 Note that while-stepping steps are not counted as "hits". */
760 /* Cached sum of the sizes of traceframes created by this point. */
761 uint64_t traceframe_usage
;
763 CORE_ADDR compiled_cond
;
765 /* Link to the next tracepoint in the list. */
766 struct tracepoint
*next
;
768 #ifndef IN_PROCESS_AGENT
769 /* The list of actions to take when the tracepoint triggers, in
770 string/packet form. */
773 /* The collection of strings that describe the tracepoint as it was
774 entered into GDB. These are not used by the target, but are
775 reported back to GDB upon reconnection. */
776 struct source_string
*source_strings
;
778 /* The number of bytes displaced by fast tracepoints. It may subsume
779 multiple instructions, for multi-byte fast tracepoints. This
780 field is only valid for fast tracepoints. */
783 /* Only for fast tracepoints. */
784 CORE_ADDR obj_addr_on_target
;
786 /* Address range where the original instruction under a fast
787 tracepoint was relocated to. (_end is actually one byte past
789 CORE_ADDR adjusted_insn_addr
;
790 CORE_ADDR adjusted_insn_addr_end
;
792 /* The address range of the piece of the jump pad buffer that was
793 assigned to this fast tracepoint. (_end is actually one byte
796 CORE_ADDR jump_pad_end
;
798 /* The address range of the piece of the trampoline buffer that was
799 assigned to this fast tracepoint. (_end is actually one byte
801 CORE_ADDR trampoline
;
802 CORE_ADDR trampoline_end
;
804 /* The list of actions to take while in a stepping loop. These
805 fields are only valid for patch-based tracepoints. */
806 int num_step_actions
;
807 struct tracepoint_action
**step_actions
;
808 /* Same, but in string/packet form. */
809 char **step_actions_str
;
811 /* Handle returned by the breakpoint or tracepoint module when we
812 inserted the trap or jump, or hooked into a static tracepoint.
813 NULL if we haven't inserted it yet. */
819 #ifndef IN_PROCESS_AGENT
821 /* Given `while-stepping', a thread may be collecting data for more
822 than one tracepoint simultaneously. On the other hand, the same
823 tracepoint with a while-stepping action may be hit by more than one
824 thread simultaneously (but not quite, each thread could be handling
825 a different step). Each thread holds a list of these objects,
826 representing the current step of each while-stepping action being
831 struct wstep_state
*next
;
833 /* The tracepoint number. */
835 /* The tracepoint's address. */
836 CORE_ADDR tp_address
;
838 /* The number of the current step in this 'while-stepping'
845 /* The linked list of all tracepoints. Marked explicitly as used as
846 the in-process library doesn't use it for the fast tracepoints
848 IP_AGENT_EXPORT
struct tracepoint
*tracepoints ATTR_USED
;
850 #ifndef IN_PROCESS_AGENT
852 /* Pointer to the last tracepoint in the list, new tracepoints are
853 linked in at the end. */
855 static struct tracepoint
*last_tracepoint
;
858 /* The first tracepoint to exceed its pass count. */
860 IP_AGENT_EXPORT
struct tracepoint
*stopping_tracepoint
;
862 /* True if the trace buffer is full or otherwise no longer usable. */
864 IP_AGENT_EXPORT
int trace_buffer_is_full
;
866 static enum eval_result_type expr_eval_result
= expr_eval_no_error
;
868 #ifndef IN_PROCESS_AGENT
870 static const char *eval_result_names
[] =
872 "terror:in the attic", /* this should never be reported */
873 "terror:empty expression",
874 "terror:empty stack",
875 "terror:stack overflow",
876 "terror:stack underflow",
877 "terror:unhandled opcode",
878 "terror:unrecognized opcode",
879 "terror:divide by zero"
884 /* The tracepoint in which the error occurred. */
886 static struct tracepoint
*error_tracepoint
;
888 struct trace_state_variable
890 /* This is the name of the variable as used in GDB. The target
891 doesn't use the name, but needs to have it for saving and
892 reconnection purposes. */
895 /* This number identifies the variable uniquely. Numbers may be
896 assigned either by the target (in the case of builtin variables),
897 or by GDB, and are presumed unique during the course of a trace
901 /* The variable's initial value, a 64-bit signed integer always. */
902 LONGEST initial_value
;
904 /* The variable's value, a 64-bit signed integer always. */
907 /* Pointer to a getter function, used to supply computed values. */
908 LONGEST (*getter
) (void);
910 /* Link to the next variable. */
911 struct trace_state_variable
*next
;
914 /* Linked list of all trace state variables. */
916 #ifdef IN_PROCESS_AGENT
917 struct trace_state_variable
*alloced_trace_state_variables
;
920 IP_AGENT_EXPORT
struct trace_state_variable
*trace_state_variables
;
922 /* The results of tracing go into a fixed-size space known as the
923 "trace buffer". Because usage follows a limited number of
924 patterns, we manage it ourselves rather than with malloc. Basic
925 rules are that we create only one trace frame at a time, each is
926 variable in size, they are never moved once created, and we only
927 discard if we are doing a circular buffer, and then only the oldest
928 ones. Each trace frame includes its own size, so we don't need to
929 link them together, and the trace frame number is relative to the
930 first one, so we don't need to record numbers. A trace frame also
931 records the number of the tracepoint that created it. The data
932 itself is a series of blocks, each introduced by a single character
933 and with a defined format. Each type of block has enough
934 type/length info to allow scanners to jump quickly from one block
935 to the next without reading each byte in the block. */
937 /* Trace buffer management would be simple - advance a free pointer
938 from beginning to end, then stop - were it not for the circular
939 buffer option, which is a useful way to prevent a trace run from
940 stopping prematurely because the buffer filled up. In the circular
941 case, the location of the first trace frame (trace_buffer_start)
942 moves as old trace frames are discarded. Also, since we grow trace
943 frames incrementally as actions are performed, we wrap around to
944 the beginning of the trace buffer. This is per-block, so each
945 block within a trace frame remains contiguous. Things get messy
946 when the wrapped-around trace frame is the one being discarded; the
947 free space ends up in two parts at opposite ends of the buffer. */
950 # if defined(__GNUC__)
951 # define ATTR_PACKED __attribute__ ((packed))
953 # define ATTR_PACKED /* nothing */
957 /* The data collected at a tracepoint hit. This object should be as
958 small as possible, since there may be a great many of them. We do
959 not need to keep a frame number, because they are all sequential
960 and there are no deletions; so the Nth frame in the buffer is
961 always frame number N. */
965 /* Number of the tracepoint that collected this traceframe. A value
966 of 0 indicates the current end of the trace buffer. We make this
967 a 16-bit field because it's never going to happen that GDB's
968 numbering of tracepoints reaches 32,000. */
971 /* The size of the data in this trace frame. We limit this to 32
972 bits, even on a 64-bit target, because it's just implausible that
973 one is validly going to collect 4 gigabytes of data at a single
975 unsigned int data_size
: 32;
977 /* The base of the trace data, which is contiguous from this point. */
978 unsigned char data
[0];
982 /* The traceframe to be used as the source of data to send back to
983 GDB. A value of -1 means to get data from the live program. */
985 int current_traceframe
= -1;
987 /* This flag is true if the trace buffer is circular, meaning that
988 when it fills, the oldest trace frames are discarded in order to
991 #ifndef IN_PROCESS_AGENT
992 static int circular_trace_buffer
;
995 /* Pointer to the block of memory that traceframes all go into. */
997 static unsigned char *trace_buffer_lo
;
999 /* Pointer to the end of the trace buffer, more precisely to the byte
1000 after the end of the buffer. */
1002 static unsigned char *trace_buffer_hi
;
1004 /* Control structure holding the read/write/etc. pointers into the
1005 trace buffer. We need more than one of these to implement a
1006 transaction-like mechanism to garantees that both GDBserver and the
1007 in-process agent can try to change the trace buffer
1010 struct trace_buffer_control
1012 /* Pointer to the first trace frame in the buffer. In the
1013 non-circular case, this is equal to trace_buffer_lo, otherwise it
1014 moves around in the buffer. */
1015 unsigned char *start
;
1017 /* Pointer to the free part of the trace buffer. Note that we clear
1018 several bytes at and after this pointer, so that traceframe
1019 scans/searches terminate properly. */
1020 unsigned char *free
;
1022 /* Pointer to the byte after the end of the free part. Note that
1023 this may be smaller than trace_buffer_free in the circular case,
1024 and means that the free part is in two pieces. Initially it is
1025 equal to trace_buffer_hi, then is generally equivalent to
1026 trace_buffer_start. */
1027 unsigned char *end_free
;
1029 /* Pointer to the wraparound. If not equal to trace_buffer_hi, then
1030 this is the point at which the trace data breaks, and resumes at
1032 unsigned char *wrap
;
1035 /* Same as above, to be used by GDBserver when updating the in-process
1037 struct ipa_trace_buffer_control
1046 /* We have possibly both GDBserver and an inferior thread accessing
1047 the same IPA trace buffer memory. The IPA is the producer (tries
1048 to put new frames in the buffer), while GDBserver occasionally
1049 consumes them, that is, flushes the IPA's buffer into its own
1050 buffer. Both sides need to update the trace buffer control
1051 pointers (current head, tail, etc.). We can't use a global lock to
1052 synchronize the accesses, as otherwise we could deadlock GDBserver
1053 (if the thread holding the lock stops for a signal, say). So
1054 instead of that, we use a transaction scheme where GDBserver writes
1055 always prevail over the IPAs writes, and, we have the IPA detect
1056 the commit failure/overwrite, and retry the whole attempt. This is
1057 mainly implemented by having a global token object that represents
1058 who wrote last to the buffer control structure. We need to freeze
1059 any inferior writing to the buffer while GDBserver touches memory,
1060 so that the inferior can correctly detect that GDBserver had been
1061 there, otherwise, it could mistakingly think its commit was
1062 successful; that's implemented by simply having GDBserver set a
1063 breakpoint the inferior hits if it is the critical region.
1065 There are three cycling trace buffer control structure copies
1066 (buffer head, tail, etc.), with the token object including an index
1067 indicating which is current live copy. The IPA tentatively builds
1068 an updated copy in a non-current control structure, while GDBserver
1069 always clobbers the current version directly. The IPA then tries
1070 to atomically "commit" its version; if GDBserver clobbered the
1071 structure meanwhile, that will fail, and the IPA restarts the
1074 Listing the step in further detail, we have:
1076 In-process agent (producer):
1078 - passes by `about_to_request_buffer_space' breakpoint/lock
1080 - reads current token, extracts current trace buffer control index,
1081 and starts tentatively updating the rightmost one (0->1, 1->2,
1082 2->0). Note that only one inferior thread is executing this code
1083 at any given time, due to an outer lock in the jump pads.
1085 - updates counters, and tries to commit the token.
1087 - passes by second `about_to_request_buffer_space' breakpoint/lock,
1088 leaving the sync region.
1090 - checks if the update was effective.
1092 - if trace buffer was found full, hits flush_trace_buffer
1093 breakpoint, and restarts later afterwards.
1095 GDBserver (consumer):
1097 - sets `about_to_request_buffer_space' breakpoint/lock.
1099 - updates the token unconditionally, using the current buffer
1100 control index, since it knows that the IP agent always writes to
1101 the rightmost, and due to the breakpoint, at most one IP thread
1102 can try to update the trace buffer concurrently to GDBserver, so
1103 there will be no danger of trace buffer control index wrap making
1104 the IPA write to the same index as GDBserver.
1106 - flushes the IP agent's trace buffer completely, and updates the
1107 current trace buffer control structure. GDBserver *always* wins.
1109 - removes the `about_to_request_buffer_space' breakpoint.
1111 The token is stored in the `trace_buffer_ctrl_curr' variable.
1112 Internally, it's bits are defined as:
1114 |-------------+-----+-------------+--------+-------------+--------------|
1115 | Bit offsets | 31 | 30 - 20 | 19 | 18-8 | 7-0 |
1116 |-------------+-----+-------------+--------+-------------+--------------|
1117 | What | GSB | PC (11-bit) | unused | CC (11-bit) | TBCI (8-bit) |
1118 |-------------+-----+-------------+--------+-------------+--------------|
1120 GSB - GDBserver Stamp Bit
1121 PC - Previous Counter
1122 CC - Current Counter
1123 TBCI - Trace Buffer Control Index
1126 An IPA update of `trace_buffer_ctrl_curr' does:
1128 - read CC from the current token, save as PC.
1130 - atomically tries to write PC+1,CC
1132 A GDBserver update of `trace_buffer_ctrl_curr' does:
1134 - reads PC and CC from the current token.
1139 /* These are the bits of `trace_buffer_ctrl_curr' that are reserved
1140 for the counters described below. The cleared bits are used to
1141 hold the index of the items of the `trace_buffer_ctrl' array that
1143 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1145 /* `trace_buffer_ctrl_curr' contains two counters. The `previous'
1146 counter, and the `current' counter. */
1148 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1149 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1151 /* When GDBserver update the IP agent's `trace_buffer_ctrl_curr', it
1152 always stamps this bit as set. */
1153 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1155 #ifdef IN_PROCESS_AGENT
1156 IP_AGENT_EXPORT
struct trace_buffer_control trace_buffer_ctrl
[3];
1157 IP_AGENT_EXPORT
unsigned int trace_buffer_ctrl_curr
;
1159 # define TRACE_BUFFER_CTRL_CURR \
1160 (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1164 /* The GDBserver side agent only needs one instance of this object, as
1165 it doesn't need to sync with itself. Define it as array anyway so
1166 that the rest of the code base doesn't need to care for the
1168 struct trace_buffer_control trace_buffer_ctrl
[1];
1169 # define TRACE_BUFFER_CTRL_CURR 0
1172 /* These are convenience macros used to access the current trace
1173 buffer control in effect. */
1174 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1175 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1176 #define trace_buffer_end_free \
1177 (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1178 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1181 /* Macro that returns a pointer to the first traceframe in the buffer. */
1183 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1185 /* Macro that returns a pointer to the next traceframe in the buffer.
1186 If the computed location is beyond the wraparound point, subtract
1187 the offset of the wraparound. */
1189 #define NEXT_TRACEFRAME_1(TF) \
1190 (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1192 #define NEXT_TRACEFRAME(TF) \
1193 ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1194 - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1195 ? (trace_buffer_wrap - trace_buffer_lo) \
1198 /* The difference between these counters represents the total number
1199 of complete traceframes present in the trace buffer. The IP agent
1200 writes to the write count, GDBserver writes to read count. */
1202 IP_AGENT_EXPORT
unsigned int traceframe_write_count
;
1203 IP_AGENT_EXPORT
unsigned int traceframe_read_count
;
1205 /* Convenience macro. */
1207 #define traceframe_count \
1208 ((unsigned int) (traceframe_write_count - traceframe_read_count))
1210 /* The count of all traceframes created in the current run, including
1211 ones that were discarded to make room. */
1213 IP_AGENT_EXPORT
int traceframes_created
;
1215 #ifndef IN_PROCESS_AGENT
1217 /* Read-only regions are address ranges whose contents don't change,
1218 and so can be read from target memory even while looking at a trace
1219 frame. Without these, disassembly for instance will likely fail,
1220 because the program code is not usually collected into a trace
1221 frame. This data structure does not need to be very complicated or
1222 particularly efficient, it's only going to be used occasionally,
1223 and only by some commands. */
1225 struct readonly_region
1227 /* The bounds of the region. */
1228 CORE_ADDR start
, end
;
1230 /* Link to the next one. */
1231 struct readonly_region
*next
;
1234 /* Linked list of readonly regions. This list stays in effect from
1235 one tstart to the next. */
1237 static struct readonly_region
*readonly_regions
;
1241 /* The global that controls tracing overall. */
1243 IP_AGENT_EXPORT
int tracing
;
1245 #ifndef IN_PROCESS_AGENT
1247 /* Controls whether tracing should continue after GDB disconnects. */
1249 int disconnected_tracing
;
1251 /* The reason for the last tracing run to have stopped. We initialize
1252 to a distinct string so that GDB can distinguish between "stopped
1253 after running" and "stopped because never run" cases. */
1255 static const char *tracing_stop_reason
= "tnotrun";
1257 static int tracing_stop_tpnum
;
1259 /* 64-bit timestamps for the trace run's start and finish, expressed
1260 in microseconds from the Unix epoch. */
1262 LONGEST tracing_start_time
;
1263 LONGEST tracing_stop_time
;
1265 /* The (optional) user-supplied name of the user that started the run.
1266 This is an arbitrary string, and may be NULL. */
1268 char *tracing_user_name
;
1270 /* Optional user-supplied text describing the run. This is
1271 an arbitrary string, and may be NULL. */
1273 char *tracing_notes
;
1275 /* Optional user-supplied text explaining a tstop command. This is an
1276 arbitrary string, and may be NULL. */
1278 char *tracing_stop_note
;
1282 /* Functions local to this file. */
1284 /* Base "class" for tracepoint type specific data to be passed down to
1285 collect_data_at_tracepoint. */
1286 struct tracepoint_hit_ctx
1288 enum tracepoint_type type
;
1291 #ifdef IN_PROCESS_AGENT
1293 /* Fast/jump tracepoint specific data to be passed down to
1294 collect_data_at_tracepoint. */
1295 struct fast_tracepoint_ctx
1297 struct tracepoint_hit_ctx base
;
1299 struct regcache regcache
;
1300 int regcache_initted
;
1301 unsigned char *regspace
;
1303 unsigned char *regs
;
1304 struct tracepoint
*tpoint
;
1307 /* Static tracepoint specific data to be passed down to
1308 collect_data_at_tracepoint. */
1309 struct static_tracepoint_ctx
1311 struct tracepoint_hit_ctx base
;
1313 /* The regcache corresponding to the registers state at the time of
1314 the tracepoint hit. Initialized lazily, from REGS. */
1315 struct regcache regcache
;
1316 int regcache_initted
;
1318 /* The buffer space REGCACHE above uses. We use a separate buffer
1319 instead of letting the regcache malloc for both signal safety and
1320 performance reasons; this is allocated on the stack instead. */
1321 unsigned char *regspace
;
1323 /* The register buffer as passed on by lttng/ust. */
1324 struct registers
*regs
;
1326 /* The "printf" formatter and the args the user passed to the marker
1327 call. We use this to be able to collect "static trace data"
1332 /* The GDB tracepoint matching the probed marker that was "hit". */
1333 struct tracepoint
*tpoint
;
1338 /* Static tracepoint specific data to be passed down to
1339 collect_data_at_tracepoint. */
1340 struct trap_tracepoint_ctx
1342 struct tracepoint_hit_ctx base
;
1344 struct regcache
*regcache
;
1349 #ifndef IN_PROCESS_AGENT
1350 static CORE_ADDR
traceframe_get_pc (struct traceframe
*tframe
);
1351 static int traceframe_read_tsv (int num
, LONGEST
*val
);
1354 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1355 struct tracepoint
*tpoint
);
1357 #ifndef IN_PROCESS_AGENT
1358 static void clear_readonly_regions (void);
1359 static void clear_installed_tracepoints (void);
1362 static void collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1364 struct tracepoint
*tpoint
);
1365 #ifndef IN_PROCESS_AGENT
1366 static void collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
1368 struct tracepoint
*tpoint
, int current_step
);
1369 static void compile_tracepoint_condition (struct tracepoint
*tpoint
,
1370 CORE_ADDR
*jump_entry
);
1372 static void do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1374 struct tracepoint
*tpoint
,
1375 struct traceframe
*tframe
,
1376 struct tracepoint_action
*taction
);
1378 #ifndef IN_PROCESS_AGENT
1379 static struct tracepoint
*fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR
);
1381 static void install_tracepoint (struct tracepoint
*, char *own_buf
);
1382 static void download_tracepoint (struct tracepoint
*);
1383 static int install_fast_tracepoint (struct tracepoint
*, char *errbuf
);
1384 static void clone_fast_tracepoint (struct tracepoint
*to
,
1385 const struct tracepoint
*from
);
1388 static LONGEST
get_timestamp (void);
1390 #if defined(__GNUC__)
1391 # define memory_barrier() asm volatile ("" : : : "memory")
1393 # define memory_barrier() do {} while (0)
1396 /* We only build the IPA if this builtin is supported, and there are
1397 no uses of this in GDBserver itself, so we're safe in defining this
1399 #define cmpxchg(mem, oldval, newval) \
1400 __sync_val_compare_and_swap (mem, oldval, newval)
1402 /* Record that an error occurred during expression evaluation. */
1405 record_tracepoint_error (struct tracepoint
*tpoint
, const char *which
,
1406 enum eval_result_type rtype
)
1408 trace_debug ("Tracepoint %d at %s %s eval reports error %d",
1409 tpoint
->number
, paddress (tpoint
->address
), which
, rtype
);
1411 #ifdef IN_PROCESS_AGENT
1412 /* Only record the first error we get. */
1413 if (cmpxchg (&expr_eval_result
,
1415 rtype
) != expr_eval_no_error
)
1418 if (expr_eval_result
!= expr_eval_no_error
)
1422 error_tracepoint
= tpoint
;
1425 /* Trace buffer management. */
1428 clear_trace_buffer (void)
1430 trace_buffer_start
= trace_buffer_lo
;
1431 trace_buffer_free
= trace_buffer_lo
;
1432 trace_buffer_end_free
= trace_buffer_hi
;
1433 trace_buffer_wrap
= trace_buffer_hi
;
1434 /* A traceframe with zeroed fields marks the end of trace data. */
1435 ((struct traceframe
*) trace_buffer_free
)->tpnum
= 0;
1436 ((struct traceframe
*) trace_buffer_free
)->data_size
= 0;
1437 traceframe_read_count
= traceframe_write_count
= 0;
1438 traceframes_created
= 0;
1441 #ifndef IN_PROCESS_AGENT
1444 clear_inferior_trace_buffer (void)
1446 CORE_ADDR ipa_trace_buffer_lo
;
1447 CORE_ADDR ipa_trace_buffer_hi
;
1448 struct traceframe ipa_traceframe
= { 0 };
1449 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
1451 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
1452 &ipa_trace_buffer_lo
);
1453 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
1454 &ipa_trace_buffer_hi
);
1456 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
1457 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
1458 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
1459 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
1461 /* A traceframe with zeroed fields marks the end of trace data. */
1462 write_inferior_memory (ipa_sym_addrs
.addr_trace_buffer_ctrl
,
1463 (unsigned char *) &ipa_trace_buffer_ctrl
,
1464 sizeof (ipa_trace_buffer_ctrl
));
1466 write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
, 0);
1468 /* A traceframe with zeroed fields marks the end of trace data. */
1469 write_inferior_memory (ipa_trace_buffer_lo
,
1470 (unsigned char *) &ipa_traceframe
,
1471 sizeof (ipa_traceframe
));
1473 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
, 0);
1474 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
, 0);
1475 write_inferior_integer (ipa_sym_addrs
.addr_traceframes_created
, 0);
1481 init_trace_buffer (unsigned char *buf
, int bufsize
)
1483 trace_buffer_lo
= buf
;
1484 trace_buffer_hi
= trace_buffer_lo
+ bufsize
;
1486 clear_trace_buffer ();
1489 #ifdef IN_PROCESS_AGENT
1491 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
1492 about_to_request_buffer_space (void)
1494 /* GDBserver places breakpoint here while it goes about to flush
1495 data at random times. */
1496 UNKNOWN_SIDE_EFFECTS();
1501 /* Carve out a piece of the trace buffer, returning NULL in case of
1505 trace_buffer_alloc (size_t amt
)
1507 unsigned char *rslt
;
1508 struct trace_buffer_control
*tbctrl
;
1510 #ifdef IN_PROCESS_AGENT
1511 unsigned int prev
, prev_filtered
;
1512 unsigned int commit_count
;
1513 unsigned int commit
;
1514 unsigned int readout
;
1516 struct traceframe
*oldest
;
1517 unsigned char *new_start
;
1520 trace_debug ("Want to allocate %ld+%ld bytes in trace buffer",
1521 (long) amt
, (long) sizeof (struct traceframe
));
1523 /* Account for the EOB marker. */
1524 amt
+= sizeof (struct traceframe
);
1526 #ifdef IN_PROCESS_AGENT
1530 /* Read the current token and extract the index to try to write to,
1531 storing it in CURR. */
1532 prev
= trace_buffer_ctrl_curr
;
1533 prev_filtered
= prev
& ~GDBSERVER_FLUSH_COUNT_MASK
;
1534 curr
= prev_filtered
+ 1;
1538 about_to_request_buffer_space ();
1540 /* Start out with a copy of the current state. GDBserver may be
1541 midway writing to the PREV_FILTERED TBC, but, that's OK, we won't
1542 be able to commit anyway if that happens. */
1543 trace_buffer_ctrl
[curr
]
1544 = trace_buffer_ctrl
[prev_filtered
];
1545 trace_debug ("trying curr=%u", curr
);
1547 /* The GDBserver's agent doesn't need all that syncing, and always
1548 updates TCB 0 (there's only one, mind you). */
1551 tbctrl
= &trace_buffer_ctrl
[curr
];
1553 /* Offsets are easier to grok for debugging than raw addresses,
1554 especially for the small trace buffer sizes that are useful for
1556 trace_debug ("Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1558 (int) (tbctrl
->start
- trace_buffer_lo
),
1559 (int) (tbctrl
->free
- trace_buffer_lo
),
1560 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1561 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1562 (int) (trace_buffer_hi
- trace_buffer_lo
));
1564 /* The algorithm here is to keep trying to get a contiguous block of
1565 the requested size, possibly discarding older traceframes to free
1566 up space. Since free space might come in one or two pieces,
1567 depending on whether discarded traceframes wrapped around at the
1568 high end of the buffer, we test both pieces after each
1572 /* First, if we have two free parts, try the upper one first. */
1573 if (tbctrl
->end_free
< tbctrl
->free
)
1575 if (tbctrl
->free
+ amt
<= trace_buffer_hi
)
1576 /* We have enough in the upper part. */
1580 /* Our high part of free space wasn't enough. Give up
1581 on it for now, set wraparound. We will recover the
1582 space later, if/when the wrapped-around traceframe is
1584 trace_debug ("Upper part too small, setting wraparound");
1585 tbctrl
->wrap
= tbctrl
->free
;
1586 tbctrl
->free
= trace_buffer_lo
;
1590 /* The normal case. */
1591 if (tbctrl
->free
+ amt
<= tbctrl
->end_free
)
1594 #ifdef IN_PROCESS_AGENT
1595 /* The IP Agent's buffer is always circular. It isn't used
1596 currently, but `circular_trace_buffer' could represent
1597 GDBserver's mode. If we didn't find space, ask GDBserver to
1600 flush_trace_buffer ();
1604 trace_debug ("gdbserver flushed buffer, retrying");
1608 /* GDBserver cancelled the tracing. Bail out as well. */
1611 /* If we're here, then neither part is big enough, and
1612 non-circular trace buffers are now full. */
1613 if (!circular_trace_buffer
)
1615 trace_debug ("Not enough space in the trace buffer");
1619 trace_debug ("Need more space in the trace buffer");
1621 /* If we have a circular buffer, we can try discarding the
1622 oldest traceframe and see if that helps. */
1623 oldest
= FIRST_TRACEFRAME ();
1624 if (oldest
->tpnum
== 0)
1626 /* Not good; we have no traceframes to free. Perhaps we're
1627 asking for a block that is larger than the buffer? In
1628 any case, give up. */
1629 trace_debug ("No traceframes to discard");
1633 /* We don't run this code in the in-process agent currently.
1634 E.g., we could leave the in-process agent in autonomous
1635 circular mode if we only have fast tracepoints. If we do
1636 that, then this bit becomes racy with GDBserver, which also
1637 writes to this counter. */
1638 --traceframe_write_count
;
1640 new_start
= (unsigned char *) NEXT_TRACEFRAME (oldest
);
1641 /* If we freed the traceframe that wrapped around, go back
1642 to the non-wrap case. */
1643 if (new_start
< tbctrl
->start
)
1645 trace_debug ("Discarding past the wraparound");
1646 tbctrl
->wrap
= trace_buffer_hi
;
1648 tbctrl
->start
= new_start
;
1649 tbctrl
->end_free
= tbctrl
->start
;
1651 trace_debug ("Discarded a traceframe\n"
1652 "Trace buffer [%d], start=%d free=%d "
1653 "endfree=%d wrap=%d hi=%d",
1655 (int) (tbctrl
->start
- trace_buffer_lo
),
1656 (int) (tbctrl
->free
- trace_buffer_lo
),
1657 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1658 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1659 (int) (trace_buffer_hi
- trace_buffer_lo
));
1661 /* Now go back around the loop. The discard might have resulted
1662 in either one or two pieces of free space, so we want to try
1663 both before freeing any more traceframes. */
1667 /* If we get here, we know we can provide the asked-for space. */
1669 rslt
= tbctrl
->free
;
1671 /* Adjust the request back down, now that we know we have space for
1672 the marker, but don't commit to AMT yet, we may still need to
1673 restart the operation if GDBserver touches the trace buffer
1674 (obviously only important in the in-process agent's version). */
1675 tbctrl
->free
+= (amt
- sizeof (struct traceframe
));
1677 /* Or not. If GDBserver changed the trace buffer behind our back,
1678 we get to restart a new allocation attempt. */
1680 #ifdef IN_PROCESS_AGENT
1681 /* Build the tentative token. */
1682 commit_count
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) + 0x100)
1683 & GDBSERVER_FLUSH_COUNT_MASK_CURR
);
1684 commit
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) << 12)
1688 /* Try to commit it. */
1689 readout
= cmpxchg (&trace_buffer_ctrl_curr
, prev
, commit
);
1690 if (readout
!= prev
)
1692 trace_debug ("GDBserver has touched the trace buffer, restarting."
1693 " (prev=%08x, commit=%08x, readout=%08x)",
1694 prev
, commit
, readout
);
1698 /* Hold your horses here. Even if that change was committed,
1699 GDBserver could come in, and clobber it. We need to hold to be
1700 able to tell if GDBserver clobbers before or after we committed
1701 the change. Whenever GDBserver goes about touching the IPA
1702 buffer, it sets a breakpoint in this routine, so we have a sync
1704 about_to_request_buffer_space ();
1706 /* Check if the change has been effective, even if GDBserver stopped
1707 us at the breakpoint. */
1710 unsigned int refetch
;
1714 refetch
= trace_buffer_ctrl_curr
;
1716 if (refetch
== commit
1717 || ((refetch
& GDBSERVER_FLUSH_COUNT_MASK_PREV
) >> 12) == commit_count
)
1720 trace_debug ("change is effective: (prev=%08x, commit=%08x, "
1721 "readout=%08x, refetch=%08x)",
1722 prev
, commit
, readout
, refetch
);
1726 trace_debug ("GDBserver has touched the trace buffer, not effective."
1727 " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1728 prev
, commit
, readout
, refetch
);
1734 /* We have a new piece of the trace buffer. Hurray! */
1736 /* Add an EOB marker just past this allocation. */
1737 ((struct traceframe
*) tbctrl
->free
)->tpnum
= 0;
1738 ((struct traceframe
*) tbctrl
->free
)->data_size
= 0;
1740 /* Adjust the request back down, now that we know we have space for
1742 amt
-= sizeof (struct traceframe
);
1746 trace_debug ("Allocated %d bytes", (int) amt
);
1747 trace_debug ("Trace buffer [%d] start=%d free=%d "
1748 "endfree=%d wrap=%d hi=%d",
1750 (int) (tbctrl
->start
- trace_buffer_lo
),
1751 (int) (tbctrl
->free
- trace_buffer_lo
),
1752 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1753 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1754 (int) (trace_buffer_hi
- trace_buffer_lo
));
1760 #ifndef IN_PROCESS_AGENT
1762 /* Return the total free space. This is not necessarily the largest
1763 block we can allocate, because of the two-part case. */
1768 if (trace_buffer_free
<= trace_buffer_end_free
)
1769 return trace_buffer_end_free
- trace_buffer_free
;
1771 return ((trace_buffer_end_free
- trace_buffer_lo
)
1772 + (trace_buffer_hi
- trace_buffer_free
));
1775 /* An 'S' in continuation packets indicates remainder are for
1778 static int seen_step_action_flag
;
1780 /* Create a tracepoint (location) with given number and address. Add this
1781 new tracepoint to list and sort this list. */
1783 static struct tracepoint
*
1784 add_tracepoint (int num
, CORE_ADDR addr
)
1786 struct tracepoint
*tpoint
, **tp_next
;
1788 tpoint
= xmalloc (sizeof (struct tracepoint
));
1789 tpoint
->number
= num
;
1790 tpoint
->address
= addr
;
1791 tpoint
->numactions
= 0;
1792 tpoint
->actions
= NULL
;
1793 tpoint
->actions_str
= NULL
;
1794 tpoint
->cond
= NULL
;
1795 tpoint
->num_step_actions
= 0;
1796 tpoint
->step_actions
= NULL
;
1797 tpoint
->step_actions_str
= NULL
;
1798 /* Start all off as regular (slow) tracepoints. */
1799 tpoint
->type
= trap_tracepoint
;
1800 tpoint
->orig_size
= -1;
1801 tpoint
->source_strings
= NULL
;
1802 tpoint
->compiled_cond
= 0;
1803 tpoint
->handle
= NULL
;
1804 tpoint
->next
= NULL
;
1806 /* Find a place to insert this tracepoint into list in order to keep
1807 the tracepoint list still in the ascending order. There may be
1808 multiple tracepoints at the same address as TPOINT's, and this
1809 guarantees TPOINT is inserted after all the tracepoints which are
1810 set at the same address. For example, fast tracepoints A, B, C are
1811 set at the same address, and D is to be insert at the same place as
1814 -->| A |--> | B |-->| C |->...
1816 One jump pad was created for tracepoint A, B, and C, and the target
1817 address of A is referenced/used in jump pad. So jump pad will let
1818 inferior jump to A. If D is inserted in front of A, like this,
1820 -->| D |-->| A |--> | B |-->| C |->...
1822 without updating jump pad, D is not reachable during collect, which
1823 is wrong. As we can see, the order of B, C and D doesn't matter, but
1824 A should always be the `first' one. */
1825 for (tp_next
= &tracepoints
;
1826 (*tp_next
) != NULL
&& (*tp_next
)->address
<= tpoint
->address
;
1827 tp_next
= &(*tp_next
)->next
)
1829 tpoint
->next
= *tp_next
;
1831 last_tracepoint
= tpoint
;
1833 seen_step_action_flag
= 0;
1838 #ifndef IN_PROCESS_AGENT
1840 /* Return the tracepoint with the given number and address, or NULL. */
1842 static struct tracepoint
*
1843 find_tracepoint (int id
, CORE_ADDR addr
)
1845 struct tracepoint
*tpoint
;
1847 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
1848 if (tpoint
->number
== id
&& tpoint
->address
== addr
)
1854 /* Remove TPOINT from global list. */
1857 remove_tracepoint (struct tracepoint
*tpoint
)
1859 struct tracepoint
*tp
, *tp_prev
;
1861 for (tp
= tracepoints
, tp_prev
= NULL
; tp
&& tp
!= tpoint
;
1862 tp_prev
= tp
, tp
= tp
->next
)
1868 tp_prev
->next
= tp
->next
;
1870 tracepoints
= tp
->next
;
1876 /* There may be several tracepoints with the same number (because they
1877 are "locations", in GDB parlance); return the next one after the
1878 given tracepoint, or search from the beginning of the list if the
1879 first argument is NULL. */
1881 static struct tracepoint
*
1882 find_next_tracepoint_by_number (struct tracepoint
*prev_tp
, int num
)
1884 struct tracepoint
*tpoint
;
1887 tpoint
= prev_tp
->next
;
1889 tpoint
= tracepoints
;
1890 for (; tpoint
; tpoint
= tpoint
->next
)
1891 if (tpoint
->number
== num
)
1899 /* Append another action to perform when the tracepoint triggers. */
1902 add_tracepoint_action (struct tracepoint
*tpoint
, char *packet
)
1908 seen_step_action_flag
= 1;
1916 char *act_start
= act
;
1917 struct tracepoint_action
*action
= NULL
;
1923 struct collect_memory_action
*maction
;
1927 maction
= xmalloc (sizeof *maction
);
1928 maction
->base
.type
= *act
;
1929 maction
->base
.ops
= &m_tracepoint_action_ops
;
1930 action
= &maction
->base
;
1933 is_neg
= (*act
== '-');
1936 act
= unpack_varlen_hex (act
, &basereg
);
1938 act
= unpack_varlen_hex (act
, &maction
->addr
);
1940 act
= unpack_varlen_hex (act
, &maction
->len
);
1941 maction
->basereg
= (is_neg
1944 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
1945 pulongest (maction
->len
),
1946 paddress (maction
->addr
), maction
->basereg
);
1951 struct collect_registers_action
*raction
;
1953 raction
= xmalloc (sizeof *raction
);
1954 raction
->base
.type
= *act
;
1955 raction
->base
.ops
= &r_tracepoint_action_ops
;
1956 action
= &raction
->base
;
1958 trace_debug ("Want to collect registers");
1960 /* skip past hex digits of mask for now */
1961 while (isxdigit(*act
))
1967 struct collect_static_trace_data_action
*raction
;
1969 raction
= xmalloc (sizeof *raction
);
1970 raction
->base
.type
= *act
;
1971 raction
->base
.ops
= &l_tracepoint_action_ops
;
1972 action
= &raction
->base
;
1974 trace_debug ("Want to collect static trace data");
1979 trace_debug ("Unexpected step action, ignoring");
1984 struct eval_expr_action
*xaction
;
1986 xaction
= xmalloc (sizeof (*xaction
));
1987 xaction
->base
.type
= *act
;
1988 xaction
->base
.ops
= &x_tracepoint_action_ops
;
1989 action
= &xaction
->base
;
1991 trace_debug ("Want to evaluate expression");
1992 xaction
->expr
= gdb_parse_agent_expr (&act
);
1996 trace_debug ("unknown trace action '%c', ignoring...", *act
);
2005 if (seen_step_action_flag
)
2007 tpoint
->num_step_actions
++;
2009 tpoint
->step_actions
2010 = xrealloc (tpoint
->step_actions
,
2011 (sizeof (*tpoint
->step_actions
)
2012 * tpoint
->num_step_actions
));
2013 tpoint
->step_actions_str
2014 = xrealloc (tpoint
->step_actions_str
,
2015 (sizeof (*tpoint
->step_actions_str
)
2016 * tpoint
->num_step_actions
));
2017 tpoint
->step_actions
[tpoint
->num_step_actions
- 1] = action
;
2018 tpoint
->step_actions_str
[tpoint
->num_step_actions
- 1]
2019 = savestring (act_start
, act
- act_start
);
2023 tpoint
->numactions
++;
2025 = xrealloc (tpoint
->actions
,
2026 sizeof (*tpoint
->actions
) * tpoint
->numactions
);
2028 = xrealloc (tpoint
->actions_str
,
2029 sizeof (*tpoint
->actions_str
) * tpoint
->numactions
);
2030 tpoint
->actions
[tpoint
->numactions
- 1] = action
;
2031 tpoint
->actions_str
[tpoint
->numactions
- 1]
2032 = savestring (act_start
, act
- act_start
);
2039 /* Find or create a trace state variable with the given number. */
2041 static struct trace_state_variable
*
2042 get_trace_state_variable (int num
)
2044 struct trace_state_variable
*tsv
;
2046 #ifdef IN_PROCESS_AGENT
2047 /* Search for an existing variable. */
2048 for (tsv
= alloced_trace_state_variables
; tsv
; tsv
= tsv
->next
)
2049 if (tsv
->number
== num
)
2053 /* Search for an existing variable. */
2054 for (tsv
= trace_state_variables
; tsv
; tsv
= tsv
->next
)
2055 if (tsv
->number
== num
)
2061 /* Find or create a trace state variable with the given number. */
2063 static struct trace_state_variable
*
2064 create_trace_state_variable (int num
, int gdb
)
2066 struct trace_state_variable
*tsv
;
2068 tsv
= get_trace_state_variable (num
);
2072 /* Create a new variable. */
2073 tsv
= xmalloc (sizeof (struct trace_state_variable
));
2075 tsv
->initial_value
= 0;
2079 #ifdef IN_PROCESS_AGENT
2082 tsv
->next
= alloced_trace_state_variables
;
2083 alloced_trace_state_variables
= tsv
;
2088 tsv
->next
= trace_state_variables
;
2089 trace_state_variables
= tsv
;
2094 IP_AGENT_EXPORT LONGEST
2095 get_trace_state_variable_value (int num
)
2097 struct trace_state_variable
*tsv
;
2099 tsv
= get_trace_state_variable (num
);
2103 trace_debug ("No trace state variable %d, skipping value get", num
);
2107 /* Call a getter function if we have one. While it's tempting to
2108 set up something to only call the getter once per tracepoint hit,
2109 it could run afoul of thread races. Better to let the getter
2110 handle it directly, if necessary to worry about it. */
2112 tsv
->value
= (tsv
->getter
) ();
2114 trace_debug ("get_trace_state_variable_value(%d) ==> %s",
2115 num
, plongest (tsv
->value
));
2120 IP_AGENT_EXPORT
void
2121 set_trace_state_variable_value (int num
, LONGEST val
)
2123 struct trace_state_variable
*tsv
;
2125 tsv
= get_trace_state_variable (num
);
2129 trace_debug ("No trace state variable %d, skipping value set", num
);
2137 agent_get_trace_state_variable_value (int num
)
2139 return get_trace_state_variable_value (num
);
2143 agent_set_trace_state_variable_value (int num
, LONGEST val
)
2145 set_trace_state_variable_value (num
, val
);
2149 set_trace_state_variable_name (int num
, const char *name
)
2151 struct trace_state_variable
*tsv
;
2153 tsv
= get_trace_state_variable (num
);
2157 trace_debug ("No trace state variable %d, skipping name set", num
);
2161 tsv
->name
= (char *) name
;
2165 set_trace_state_variable_getter (int num
, LONGEST (*getter
) (void))
2167 struct trace_state_variable
*tsv
;
2169 tsv
= get_trace_state_variable (num
);
2173 trace_debug ("No trace state variable %d, skipping getter set", num
);
2177 tsv
->getter
= getter
;
2180 /* Add a raw traceframe for the given tracepoint. */
2182 static struct traceframe
*
2183 add_traceframe (struct tracepoint
*tpoint
)
2185 struct traceframe
*tframe
;
2187 tframe
= trace_buffer_alloc (sizeof (struct traceframe
));
2192 tframe
->tpnum
= tpoint
->number
;
2193 tframe
->data_size
= 0;
2198 /* Add a block to the traceframe currently being worked on. */
2200 static unsigned char *
2201 add_traceframe_block (struct traceframe
*tframe
,
2202 struct tracepoint
*tpoint
, int amt
)
2204 unsigned char *block
;
2209 block
= trace_buffer_alloc (amt
);
2214 gdb_assert (tframe
->tpnum
== tpoint
->number
);
2216 tframe
->data_size
+= amt
;
2217 tpoint
->traceframe_usage
+= amt
;
2222 /* Flag that the current traceframe is finished. */
2225 finish_traceframe (struct traceframe
*tframe
)
2227 ++traceframe_write_count
;
2228 ++traceframes_created
;
2231 #ifndef IN_PROCESS_AGENT
2233 /* Given a traceframe number NUM, find the NUMth traceframe in the
2236 static struct traceframe
*
2237 find_traceframe (int num
)
2239 struct traceframe
*tframe
;
2242 for (tframe
= FIRST_TRACEFRAME ();
2244 tframe
= NEXT_TRACEFRAME (tframe
))
2255 get_traceframe_address (struct traceframe
*tframe
)
2258 struct tracepoint
*tpoint
;
2260 addr
= traceframe_get_pc (tframe
);
2265 /* Fallback strategy, will be incorrect for while-stepping frames
2266 and multi-location tracepoints. */
2267 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
2268 return tpoint
->address
;
2271 /* Search for the next traceframe whose address is inside or outside
2274 static struct traceframe
*
2275 find_next_traceframe_in_range (CORE_ADDR lo
, CORE_ADDR hi
, int inside_p
,
2278 struct traceframe
*tframe
;
2281 *tfnump
= current_traceframe
+ 1;
2282 tframe
= find_traceframe (*tfnump
);
2283 /* The search is not supposed to wrap around. */
2290 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2292 tfaddr
= get_traceframe_address (tframe
);
2294 ? (lo
<= tfaddr
&& tfaddr
<= hi
)
2295 : (lo
> tfaddr
|| tfaddr
> hi
))
2304 /* Search for the next traceframe recorded by the given tracepoint.
2305 Note that for multi-location tracepoints, this will find whatever
2306 location appears first. */
2308 static struct traceframe
*
2309 find_next_traceframe_by_tracepoint (int num
, int *tfnump
)
2311 struct traceframe
*tframe
;
2313 *tfnump
= current_traceframe
+ 1;
2314 tframe
= find_traceframe (*tfnump
);
2315 /* The search is not supposed to wrap around. */
2322 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2324 if (tframe
->tpnum
== num
)
2335 #ifndef IN_PROCESS_AGENT
2337 /* Clear all past trace state. */
2340 cmd_qtinit (char *packet
)
2342 struct trace_state_variable
*tsv
, *prev
, *next
;
2344 /* Make sure we don't try to read from a trace frame. */
2345 current_traceframe
= -1;
2347 trace_debug ("Initializing the trace");
2349 clear_installed_tracepoints ();
2350 clear_readonly_regions ();
2353 last_tracepoint
= NULL
;
2355 /* Clear out any leftover trace state variables. Ones with target
2356 defined getters should be kept however. */
2358 tsv
= trace_state_variables
;
2361 trace_debug ("Looking at var %d", tsv
->number
);
2362 if (tsv
->getter
== NULL
)
2368 trace_state_variables
= next
;
2369 trace_debug ("Deleting var %d", tsv
->number
);
2380 clear_trace_buffer ();
2381 clear_inferior_trace_buffer ();
2386 /* Unprobe the UST marker at ADDRESS. */
2389 unprobe_marker_at (CORE_ADDR address
)
2391 char cmd
[IPA_CMD_BUF_SIZE
];
2393 sprintf (cmd
, "unprobe_marker_at:%s", paddress (address
));
2394 run_inferior_command (cmd
, strlen (cmd
) + 1);
2397 /* Restore the program to its pre-tracing state. This routine may be called
2398 in error situations, so it needs to be careful about only restoring
2399 from known-valid bits. */
2402 clear_installed_tracepoints (void)
2404 struct tracepoint
*tpoint
;
2405 struct tracepoint
*prev_stpoint
;
2408 cancel_breakpoints ();
2410 prev_stpoint
= NULL
;
2412 /* Restore any bytes overwritten by tracepoints. */
2413 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
2415 /* Catch the case where we might try to remove a tracepoint that
2416 was never actually installed. */
2417 if (tpoint
->handle
== NULL
)
2419 trace_debug ("Tracepoint %d at 0x%s was "
2420 "never installed, nothing to clear",
2421 tpoint
->number
, paddress (tpoint
->address
));
2425 switch (tpoint
->type
)
2427 case trap_tracepoint
:
2428 delete_breakpoint (tpoint
->handle
);
2430 case fast_tracepoint
:
2431 delete_fast_tracepoint_jump (tpoint
->handle
);
2433 case static_tracepoint
:
2434 if (prev_stpoint
!= NULL
2435 && prev_stpoint
->address
== tpoint
->address
)
2436 /* Nothing to do. We already unprobed a tracepoint set at
2437 this marker address (and there can only be one probe
2442 unprobe_marker_at (tpoint
->address
);
2443 prev_stpoint
= tpoint
;
2448 tpoint
->handle
= NULL
;
2454 /* Parse a packet that defines a tracepoint. */
2457 cmd_qtdp (char *own_buf
)
2460 /* Whether there is a trailing hyphen at the end of the QTDP packet. */
2461 int trail_hyphen
= 0;
2465 struct tracepoint
*tpoint
;
2467 char *packet
= own_buf
;
2469 packet
+= strlen ("QTDP:");
2471 /* A hyphen at the beginning marks a packet specifying actions for a
2472 tracepoint already supplied. */
2479 packet
= unpack_varlen_hex (packet
, &num
);
2480 ++packet
; /* skip a colon */
2481 packet
= unpack_varlen_hex (packet
, &addr
);
2482 ++packet
; /* skip a colon */
2484 /* See if we already have this tracepoint. */
2485 tpoint
= find_tracepoint (num
, addr
);
2489 /* Duplicate tracepoints are never allowed. */
2492 trace_debug ("Tracepoint error: tracepoint %d"
2493 " at 0x%s already exists",
2494 (int) num
, paddress (addr
));
2495 write_enn (own_buf
);
2499 tpoint
= add_tracepoint (num
, addr
);
2501 tpoint
->enabled
= (*packet
== 'E');
2502 ++packet
; /* skip 'E' */
2503 ++packet
; /* skip a colon */
2504 packet
= unpack_varlen_hex (packet
, &count
);
2505 tpoint
->step_count
= count
;
2506 ++packet
; /* skip a colon */
2507 packet
= unpack_varlen_hex (packet
, &count
);
2508 tpoint
->pass_count
= count
;
2509 /* See if we have any of the additional optional fields. */
2510 while (*packet
== ':')
2515 tpoint
->type
= fast_tracepoint
;
2517 packet
= unpack_varlen_hex (packet
, &count
);
2518 tpoint
->orig_size
= count
;
2520 else if (*packet
== 'S')
2522 tpoint
->type
= static_tracepoint
;
2525 else if (*packet
== 'X')
2527 actparm
= (char *) packet
;
2528 tpoint
->cond
= gdb_parse_agent_expr (&actparm
);
2531 else if (*packet
== '-')
2533 else if (*packet
== '\0')
2536 trace_debug ("Unknown optional tracepoint field");
2541 trace_debug ("Also has actions\n");
2544 trace_debug ("Defined %stracepoint %d at 0x%s, "
2545 "enabled %d step %" PRIu64
" pass %" PRIu64
,
2546 tpoint
->type
== fast_tracepoint
? "fast "
2547 : tpoint
->type
== static_tracepoint
? "static " : "",
2548 tpoint
->number
, paddress (tpoint
->address
), tpoint
->enabled
,
2549 tpoint
->step_count
, tpoint
->pass_count
);
2552 add_tracepoint_action (tpoint
, packet
);
2555 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2556 (int) num
, paddress (addr
));
2557 write_enn (own_buf
);
2561 /* Install tracepoint during tracing only once for each tracepoint location.
2562 For each tracepoint loc, GDB may send multiple QTDP packets, and we can
2563 determine the last QTDP packet for one tracepoint location by checking
2564 trailing hyphen in QTDP packet. */
2565 if (tracing
&& !trail_hyphen
)
2567 struct tracepoint
*tp
= NULL
;
2569 /* Pause all threads temporarily while we patch tracepoints. */
2572 /* download_tracepoint will update global `tracepoints'
2573 list, so it is unsafe to leave threads in jump pad. */
2574 stabilize_threads ();
2576 /* Freeze threads. */
2580 if (tpoint
->type
!= trap_tracepoint
)
2582 /* Find another fast or static tracepoint at the same address. */
2583 for (tp
= tracepoints
; tp
; tp
= tp
->next
)
2585 if (tp
->address
== tpoint
->address
&& tp
->type
== tpoint
->type
2586 && tp
->number
!= tpoint
->number
)
2590 /* TPOINT is installed at the same address as TP. */
2593 if (tpoint
->type
== fast_tracepoint
)
2594 clone_fast_tracepoint (tpoint
, tp
);
2595 else if (tpoint
->type
== static_tracepoint
)
2596 tpoint
->handle
= (void *) -1;
2600 if (use_agent
&& tpoint
->type
== fast_tracepoint
2601 && agent_capability_check (AGENT_CAPA_FAST_TRACE
))
2603 /* Download and install fast tracepoint by agent. */
2604 if (tracepoint_send_agent (tpoint
) == 0)
2608 write_enn (own_buf
);
2609 remove_tracepoint (tpoint
);
2614 download_tracepoint (tpoint
);
2616 if (tpoint
->type
== trap_tracepoint
|| tp
== NULL
)
2618 install_tracepoint (tpoint
, own_buf
);
2619 if (strcmp (own_buf
, "OK") != 0)
2620 remove_tracepoint (tpoint
);
2634 cmd_qtdpsrc (char *own_buf
)
2636 ULONGEST num
, addr
, start
, slen
;
2637 struct tracepoint
*tpoint
;
2638 char *packet
= own_buf
;
2639 char *saved
, *srctype
, *src
;
2641 struct source_string
*last
, *newlast
;
2643 packet
+= strlen ("QTDPsrc:");
2645 packet
= unpack_varlen_hex (packet
, &num
);
2646 ++packet
; /* skip a colon */
2647 packet
= unpack_varlen_hex (packet
, &addr
);
2648 ++packet
; /* skip a colon */
2650 /* See if we already have this tracepoint. */
2651 tpoint
= find_tracepoint (num
, addr
);
2655 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2656 (int) num
, paddress (addr
));
2657 write_enn (own_buf
);
2662 packet
= strchr (packet
, ':');
2663 srctype
= xmalloc (packet
- saved
+ 1);
2664 memcpy (srctype
, saved
, packet
- saved
);
2665 srctype
[packet
- saved
] = '\0';
2667 packet
= unpack_varlen_hex (packet
, &start
);
2668 ++packet
; /* skip a colon */
2669 packet
= unpack_varlen_hex (packet
, &slen
);
2670 ++packet
; /* skip a colon */
2671 src
= xmalloc (slen
+ 1);
2672 nbytes
= unhexify (src
, packet
, strlen (packet
) / 2);
2675 newlast
= xmalloc (sizeof (struct source_string
));
2676 newlast
->type
= srctype
;
2678 newlast
->next
= NULL
;
2679 /* Always add a source string to the end of the list;
2680 this keeps sequences of actions/commands in the right
2682 if (tpoint
->source_strings
)
2684 for (last
= tpoint
->source_strings
; last
->next
; last
= last
->next
)
2686 last
->next
= newlast
;
2689 tpoint
->source_strings
= newlast
;
2695 cmd_qtdv (char *own_buf
)
2697 ULONGEST num
, val
, builtin
;
2700 struct trace_state_variable
*tsv
;
2701 char *packet
= own_buf
;
2703 packet
+= strlen ("QTDV:");
2705 packet
= unpack_varlen_hex (packet
, &num
);
2706 ++packet
; /* skip a colon */
2707 packet
= unpack_varlen_hex (packet
, &val
);
2708 ++packet
; /* skip a colon */
2709 packet
= unpack_varlen_hex (packet
, &builtin
);
2710 ++packet
; /* skip a colon */
2712 nbytes
= strlen (packet
) / 2;
2713 varname
= xmalloc (nbytes
+ 1);
2714 nbytes
= unhexify (varname
, packet
, nbytes
);
2715 varname
[nbytes
] = '\0';
2717 tsv
= create_trace_state_variable (num
, 1);
2718 tsv
->initial_value
= (LONGEST
) val
;
2719 tsv
->name
= varname
;
2721 set_trace_state_variable_value (num
, (LONGEST
) val
);
2727 cmd_qtenable_disable (char *own_buf
, int enable
)
2729 char *packet
= own_buf
;
2731 struct tracepoint
*tp
;
2733 packet
+= strlen (enable
? "QTEnable:" : "QTDisable:");
2734 packet
= unpack_varlen_hex (packet
, &num
);
2735 ++packet
; /* skip a colon */
2736 packet
= unpack_varlen_hex (packet
, &addr
);
2738 tp
= find_tracepoint (num
, addr
);
2742 if ((enable
&& tp
->enabled
) || (!enable
&& !tp
->enabled
))
2744 trace_debug ("Tracepoint %d at 0x%s is already %s",
2745 (int) num
, paddress (addr
),
2746 enable
? "enabled" : "disabled");
2751 trace_debug ("%s tracepoint %d at 0x%s",
2752 enable
? "Enabling" : "Disabling",
2753 (int) num
, paddress (addr
));
2755 tp
->enabled
= enable
;
2757 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
2760 int offset
= offsetof (struct tracepoint
, enabled
);
2761 CORE_ADDR obj_addr
= tp
->obj_addr_on_target
+ offset
;
2763 ret
= prepare_to_access_memory ();
2766 trace_debug ("Failed to temporarily stop inferior threads");
2767 write_enn (own_buf
);
2771 ret
= write_inferior_integer (obj_addr
, enable
);
2772 done_accessing_memory ();
2776 trace_debug ("Cannot write enabled flag into "
2777 "inferior process memory");
2778 write_enn (own_buf
);
2787 trace_debug ("Tracepoint %d at 0x%s not found",
2788 (int) num
, paddress (addr
));
2789 write_enn (own_buf
);
2794 cmd_qtv (char *own_buf
)
2799 char *packet
= own_buf
;
2801 packet
+= strlen ("qTV:");
2802 unpack_varlen_hex (packet
, &num
);
2804 if (current_traceframe
>= 0)
2806 err
= traceframe_read_tsv ((int) num
, &val
);
2809 strcpy (own_buf
, "U");
2813 /* Only make tsv's be undefined before the first trace run. After a
2814 trace run is over, the user might want to see the last value of
2815 the tsv, and it might not be available in a traceframe. */
2816 else if (!tracing
&& strcmp (tracing_stop_reason
, "tnotrun") == 0)
2818 strcpy (own_buf
, "U");
2822 val
= get_trace_state_variable_value (num
);
2824 sprintf (own_buf
, "V%s", phex_nz (val
, 0));
2827 /* Clear out the list of readonly regions. */
2830 clear_readonly_regions (void)
2832 struct readonly_region
*roreg
;
2834 while (readonly_regions
)
2836 roreg
= readonly_regions
;
2837 readonly_regions
= readonly_regions
->next
;
2842 /* Parse the collection of address ranges whose contents GDB believes
2843 to be unchanging and so can be read directly from target memory
2844 even while looking at a traceframe. */
2847 cmd_qtro (char *own_buf
)
2849 ULONGEST start
, end
;
2850 struct readonly_region
*roreg
;
2851 char *packet
= own_buf
;
2853 trace_debug ("Want to mark readonly regions");
2855 clear_readonly_regions ();
2857 packet
+= strlen ("QTro");
2859 while (*packet
== ':')
2861 ++packet
; /* skip a colon */
2862 packet
= unpack_varlen_hex (packet
, &start
);
2863 ++packet
; /* skip a comma */
2864 packet
= unpack_varlen_hex (packet
, &end
);
2865 roreg
= xmalloc (sizeof (struct readonly_region
));
2866 roreg
->start
= start
;
2868 roreg
->next
= readonly_regions
;
2869 readonly_regions
= roreg
;
2870 trace_debug ("Added readonly region from 0x%s to 0x%s",
2871 paddress (roreg
->start
), paddress (roreg
->end
));
2877 /* Test to see if the given range is in our list of readonly ranges.
2878 We only test for being entirely within a range, GDB is not going to
2879 send a single memory packet that spans multiple regions. */
2882 in_readonly_region (CORE_ADDR addr
, ULONGEST length
)
2884 struct readonly_region
*roreg
;
2886 for (roreg
= readonly_regions
; roreg
; roreg
= roreg
->next
)
2887 if (roreg
->start
<= addr
&& (addr
+ length
- 1) <= roreg
->end
)
2893 /* The maximum size of a jump pad entry. */
2894 static const int max_jump_pad_size
= 0x100;
2896 static CORE_ADDR gdb_jump_pad_head
;
2898 /* Return the address of the next free jump space. */
2901 get_jump_space_head (void)
2903 if (gdb_jump_pad_head
== 0)
2905 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
2906 &gdb_jump_pad_head
))
2907 fatal ("error extracting jump_pad_buffer");
2910 return gdb_jump_pad_head
;
2913 /* Reserve USED bytes from the jump space. */
2916 claim_jump_space (ULONGEST used
)
2918 trace_debug ("claim_jump_space reserves %s bytes at %s",
2919 pulongest (used
), paddress (gdb_jump_pad_head
));
2920 gdb_jump_pad_head
+= used
;
2923 static CORE_ADDR trampoline_buffer_head
= 0;
2924 static CORE_ADDR trampoline_buffer_tail
;
2926 /* Reserve USED bytes from the trampoline buffer and return the
2927 address of the start of the reserved space in TRAMPOLINE. Returns
2928 non-zero if the space is successfully claimed. */
2931 claim_trampoline_space (ULONGEST used
, CORE_ADDR
*trampoline
)
2933 if (!trampoline_buffer_head
)
2935 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
2936 &trampoline_buffer_tail
))
2938 fatal ("error extracting trampoline_buffer");
2942 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
2943 &trampoline_buffer_head
))
2945 fatal ("error extracting trampoline_buffer_end");
2950 /* Start claiming space from the top of the trampoline space. If
2951 the space is located at the bottom of the virtual address space,
2952 this reduces the possibility that corruption will occur if a null
2953 pointer is used to write to memory. */
2954 if (trampoline_buffer_head
- trampoline_buffer_tail
< used
)
2956 trace_debug ("claim_trampoline_space failed to reserve %s bytes",
2961 trampoline_buffer_head
-= used
;
2963 trace_debug ("claim_trampoline_space reserves %s bytes at %s",
2964 pulongest (used
), paddress (trampoline_buffer_head
));
2966 *trampoline
= trampoline_buffer_head
;
2970 /* Returns non-zero if there is space allocated for use in trampolines
2971 for fast tracepoints. */
2974 have_fast_tracepoint_trampoline_buffer (char *buf
)
2976 CORE_ADDR trampoline_end
, errbuf
;
2978 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
2981 fatal ("error extracting trampoline_buffer_end");
2988 strcpy (buf
, "was claiming");
2989 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_error
,
2992 fatal ("error extracting errbuf");
2996 read_inferior_memory (errbuf
, (unsigned char *) buf
, 100);
2999 return trampoline_end
!= 0;
3002 /* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
3003 the command fails, or 0 otherwise. If the command ran
3004 successfully, but probing the marker failed, ERROUT will be filled
3005 with the error to reply to GDB, and -1 is also returned. This
3006 allows directly passing IPA errors to GDB. */
3009 probe_marker_at (CORE_ADDR address
, char *errout
)
3011 char cmd
[IPA_CMD_BUF_SIZE
];
3014 sprintf (cmd
, "probe_marker_at:%s", paddress (address
));
3015 err
= run_inferior_command (cmd
, strlen (cmd
) + 1);
3021 strcpy (errout
, cmd
);
3030 clone_fast_tracepoint (struct tracepoint
*to
, const struct tracepoint
*from
)
3032 to
->jump_pad
= from
->jump_pad
;
3033 to
->jump_pad_end
= from
->jump_pad_end
;
3034 to
->trampoline
= from
->trampoline
;
3035 to
->trampoline_end
= from
->trampoline_end
;
3036 to
->adjusted_insn_addr
= from
->adjusted_insn_addr
;
3037 to
->adjusted_insn_addr_end
= from
->adjusted_insn_addr_end
;
3038 to
->handle
= from
->handle
;
3040 gdb_assert (from
->handle
);
3041 inc_ref_fast_tracepoint_jump ((struct fast_tracepoint_jump
*) from
->handle
);
3044 #define MAX_JUMP_SIZE 20
3046 /* Install fast tracepoint. Return 0 if successful, otherwise return
3050 install_fast_tracepoint (struct tracepoint
*tpoint
, char *errbuf
)
3052 CORE_ADDR jentry
, jump_entry
;
3053 CORE_ADDR trampoline
;
3054 ULONGEST trampoline_size
;
3056 /* The jump to the jump pad of the last fast tracepoint
3058 unsigned char fjump
[MAX_JUMP_SIZE
];
3059 ULONGEST fjump_size
;
3061 if (tpoint
->orig_size
< target_get_min_fast_tracepoint_insn_len ())
3063 trace_debug ("Requested a fast tracepoint on an instruction "
3064 "that is of less than the minimum length.");
3068 jentry
= jump_entry
= get_jump_space_head ();
3071 trampoline_size
= 0;
3073 /* Install the jump pad. */
3074 err
= install_fast_tracepoint_jump_pad (tpoint
->obj_addr_on_target
,
3076 ipa_sym_addrs
.addr_gdb_collect
,
3077 ipa_sym_addrs
.addr_collecting
,
3080 &trampoline
, &trampoline_size
,
3082 &tpoint
->adjusted_insn_addr
,
3083 &tpoint
->adjusted_insn_addr_end
,
3090 tpoint
->handle
= set_fast_tracepoint_jump (tpoint
->address
, fjump
,
3093 if (tpoint
->handle
!= NULL
)
3095 tpoint
->jump_pad
= jump_entry
;
3096 tpoint
->jump_pad_end
= jentry
;
3097 tpoint
->trampoline
= trampoline
;
3098 tpoint
->trampoline_end
= trampoline
+ trampoline_size
;
3100 /* Pad to 8-byte alignment. */
3101 jentry
= ((jentry
+ 7) & ~0x7);
3102 claim_jump_space (jentry
- jump_entry
);
3109 /* Install tracepoint TPOINT, and write reply message in OWN_BUF. */
3112 install_tracepoint (struct tracepoint
*tpoint
, char *own_buf
)
3114 tpoint
->handle
= NULL
;
3117 if (tpoint
->type
== trap_tracepoint
)
3119 /* Tracepoints are installed as memory breakpoints. Just go
3120 ahead and install the trap. The breakpoints module
3121 handles duplicated breakpoints, and the memory read
3122 routine handles un-patching traps from memory reads. */
3123 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3124 tracepoint_handler
);
3126 else if (tpoint
->type
== fast_tracepoint
|| tpoint
->type
== static_tracepoint
)
3128 if (!agent_loaded_p ())
3130 trace_debug ("Requested a %s tracepoint, but fast "
3131 "tracepoints aren't supported.",
3132 tpoint
->type
== static_tracepoint
? "static" : "fast");
3133 write_e_ipa_not_loaded (own_buf
);
3136 if (tpoint
->type
== static_tracepoint
3137 && !in_process_agent_supports_ust ())
3139 trace_debug ("Requested a static tracepoint, but static "
3140 "tracepoints are not supported.");
3141 write_e_ust_not_loaded (own_buf
);
3145 if (tpoint
->type
== fast_tracepoint
)
3146 install_fast_tracepoint (tpoint
, own_buf
);
3149 if (probe_marker_at (tpoint
->address
, own_buf
) == 0)
3150 tpoint
->handle
= (void *) -1;
3155 internal_error (__FILE__
, __LINE__
, "Unknown tracepoint type");
3157 if (tpoint
->handle
== NULL
)
3159 if (*own_buf
== '\0')
3160 write_enn (own_buf
);
3166 static void download_tracepoint_1 (struct tracepoint
*tpoint
);
3169 cmd_qtstart (char *packet
)
3171 struct tracepoint
*tpoint
, *prev_ftpoint
, *prev_stpoint
;
3172 CORE_ADDR tpptr
= 0, prev_tpptr
= 0;
3174 trace_debug ("Starting the trace");
3176 /* Pause all threads temporarily while we patch tracepoints. */
3179 /* Get threads out of jump pads. Safe to do here, since this is a
3180 top level command. And, required to do here, since we're
3181 deleting/rewriting jump pads. */
3183 stabilize_threads ();
3185 /* Freeze threads. */
3188 /* Sync the fast tracepoints list in the inferior ftlib. */
3189 if (agent_loaded_p ())
3190 download_trace_state_variables ();
3192 /* No previous fast tpoint yet. */
3193 prev_ftpoint
= NULL
;
3195 /* No previous static tpoint yet. */
3196 prev_stpoint
= NULL
;
3200 /* Start out empty. */
3201 if (agent_loaded_p ())
3202 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, 0);
3204 /* Download and install tracepoints. */
3205 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
3207 /* Ensure all the hit counts start at zero. */
3208 tpoint
->hit_count
= 0;
3209 tpoint
->traceframe_usage
= 0;
3211 if (tpoint
->type
== trap_tracepoint
)
3213 /* Tracepoints are installed as memory breakpoints. Just go
3214 ahead and install the trap. The breakpoints module
3215 handles duplicated breakpoints, and the memory read
3216 routine handles un-patching traps from memory reads. */
3217 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3218 tracepoint_handler
);
3220 else if (tpoint
->type
== fast_tracepoint
3221 || tpoint
->type
== static_tracepoint
)
3223 if (maybe_write_ipa_not_loaded (packet
))
3225 trace_debug ("Requested a %s tracepoint, but fast "
3226 "tracepoints aren't supported.",
3227 tpoint
->type
== static_tracepoint
3228 ? "static" : "fast");
3232 if (tpoint
->type
== fast_tracepoint
)
3235 = use_agent
&& agent_capability_check (AGENT_CAPA_FAST_TRACE
);
3237 if (prev_ftpoint
!= NULL
3238 && prev_ftpoint
->address
== tpoint
->address
)
3241 tracepoint_send_agent (tpoint
);
3243 download_tracepoint_1 (tpoint
);
3245 clone_fast_tracepoint (tpoint
, prev_ftpoint
);
3249 /* Tracepoint is installed successfully? */
3252 /* Download and install fast tracepoint by agent. */
3254 installed
= !tracepoint_send_agent (tpoint
);
3257 download_tracepoint_1 (tpoint
);
3258 installed
= !install_fast_tracepoint (tpoint
, packet
);
3262 prev_ftpoint
= tpoint
;
3267 if (!in_process_agent_supports_ust ())
3269 trace_debug ("Requested a static tracepoint, but static "
3270 "tracepoints are not supported.");
3274 download_tracepoint_1 (tpoint
);
3275 /* Can only probe a given marker once. */
3276 if (prev_stpoint
!= NULL
3277 && prev_stpoint
->address
== tpoint
->address
)
3278 tpoint
->handle
= (void *) -1;
3281 if (probe_marker_at (tpoint
->address
, packet
) == 0)
3283 tpoint
->handle
= (void *) -1;
3285 /* So that we can handle multiple static tracepoints
3286 at the same address easily. */
3287 prev_stpoint
= tpoint
;
3293 tpptr
= tpoint
->obj_addr_on_target
;
3295 if (tpoint
== tracepoints
)
3296 /* First object in list, set the head pointer in the
3298 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, tpptr
);
3300 write_inferior_data_ptr (prev_tpptr
+ offsetof (struct tracepoint
,
3305 /* Any failure in the inner loop is sufficient cause to give
3307 if (tpoint
->handle
== NULL
)
3311 /* Any error in tracepoint insertion is unacceptable; better to
3312 address the problem now, than end up with a useless or misleading
3316 clear_installed_tracepoints ();
3317 if (*packet
== '\0')
3323 stopping_tracepoint
= NULL
;
3324 trace_buffer_is_full
= 0;
3325 expr_eval_result
= expr_eval_no_error
;
3326 error_tracepoint
= NULL
;
3327 tracing_start_time
= get_timestamp ();
3329 /* Tracing is now active, hits will now start being logged. */
3332 if (agent_loaded_p ())
3334 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 1))
3335 fatal ("Error setting tracing variable in lib");
3337 if (write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
3339 fatal ("Error clearing stopping_tracepoint variable in lib");
3341 if (write_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
, 0))
3342 fatal ("Error clearing trace_buffer_is_full variable in lib");
3344 stop_tracing_bkpt
= set_breakpoint_at (ipa_sym_addrs
.addr_stop_tracing
,
3345 stop_tracing_handler
);
3346 if (stop_tracing_bkpt
== NULL
)
3347 error ("Error setting stop_tracing breakpoint");
3349 flush_trace_buffer_bkpt
3350 = set_breakpoint_at (ipa_sym_addrs
.addr_flush_trace_buffer
,
3351 flush_trace_buffer_handler
);
3352 if (flush_trace_buffer_bkpt
== NULL
)
3353 error ("Error setting flush_trace_buffer breakpoint");
3361 /* End a tracing run, filling in a stop reason to report back to GDB,
3362 and removing the tracepoints from the code. */
3369 trace_debug ("Tracing is already off, ignoring");
3373 trace_debug ("Stopping the trace");
3375 /* Pause all threads before removing fast jumps from memory,
3376 breakpoints, and touching IPA state variables (inferior memory).
3377 Some thread may hit the internal tracing breakpoints, or be
3378 collecting this moment, but that's ok, we don't release the
3379 tpoint object's memory or the jump pads here (we only do that
3380 when we're sure we can move all threads out of the jump pads).
3381 We can't now, since we may be getting here due to the inferior
3382 agent calling us. */
3384 /* Since we're removing breakpoints, cancel breakpoint hits,
3385 possibly related to the breakpoints we're about to delete. */
3386 cancel_breakpoints ();
3388 /* Stop logging. Tracepoints can still be hit, but they will not be
3391 if (agent_loaded_p ())
3393 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 0))
3394 fatal ("Error clearing tracing variable in lib");
3397 tracing_stop_time
= get_timestamp ();
3398 tracing_stop_reason
= "t???";
3399 tracing_stop_tpnum
= 0;
3400 if (stopping_tracepoint
)
3402 trace_debug ("Stopping the trace because "
3403 "tracepoint %d was hit %" PRIu64
" times",
3404 stopping_tracepoint
->number
,
3405 stopping_tracepoint
->pass_count
);
3406 tracing_stop_reason
= "tpasscount";
3407 tracing_stop_tpnum
= stopping_tracepoint
->number
;
3409 else if (trace_buffer_is_full
)
3411 trace_debug ("Stopping the trace because the trace buffer is full");
3412 tracing_stop_reason
= "tfull";
3414 else if (expr_eval_result
!= expr_eval_no_error
)
3416 trace_debug ("Stopping the trace because of an expression eval error");
3417 tracing_stop_reason
= eval_result_names
[expr_eval_result
];
3418 tracing_stop_tpnum
= error_tracepoint
->number
;
3420 #ifndef IN_PROCESS_AGENT
3421 else if (!gdb_connected ())
3423 trace_debug ("Stopping the trace because GDB disconnected");
3424 tracing_stop_reason
= "tdisconnected";
3429 trace_debug ("Stopping the trace because of a tstop command");
3430 tracing_stop_reason
= "tstop";
3433 stopping_tracepoint
= NULL
;
3434 error_tracepoint
= NULL
;
3436 /* Clear out the tracepoints. */
3437 clear_installed_tracepoints ();
3439 if (agent_loaded_p ())
3441 /* Pull in fast tracepoint trace frames from the inferior lib
3442 buffer into our buffer, even if our buffer is already full,
3443 because we want to present the full number of created frames
3444 in addition to what fit in the trace buffer. */
3445 upload_fast_traceframes ();
3448 if (stop_tracing_bkpt
!= NULL
)
3450 delete_breakpoint (stop_tracing_bkpt
);
3451 stop_tracing_bkpt
= NULL
;
3454 if (flush_trace_buffer_bkpt
!= NULL
)
3456 delete_breakpoint (flush_trace_buffer_bkpt
);
3457 flush_trace_buffer_bkpt
= NULL
;
3464 stop_tracing_handler (CORE_ADDR addr
)
3466 trace_debug ("lib hit stop_tracing");
3468 /* Don't actually handle it here. When we stop tracing we remove
3469 breakpoints from the inferior, and that is not allowed in a
3470 breakpoint handler (as the caller is walking the breakpoint
3476 flush_trace_buffer_handler (CORE_ADDR addr
)
3478 trace_debug ("lib hit flush_trace_buffer");
3483 cmd_qtstop (char *packet
)
3490 cmd_qtdisconnected (char *own_buf
)
3493 char *packet
= own_buf
;
3495 packet
+= strlen ("QTDisconnected:");
3497 unpack_varlen_hex (packet
, &setting
);
3501 disconnected_tracing
= setting
;
3505 cmd_qtframe (char *own_buf
)
3507 ULONGEST frame
, pc
, lo
, hi
, num
;
3509 struct traceframe
*tframe
;
3510 char *packet
= own_buf
;
3512 packet
+= strlen ("QTFrame:");
3514 if (strncmp (packet
, "pc:", strlen ("pc:")) == 0)
3516 packet
+= strlen ("pc:");
3517 unpack_varlen_hex (packet
, &pc
);
3518 trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc
));
3519 tframe
= find_next_traceframe_in_range (pc
, pc
, 1, &tfnum
);
3521 else if (strncmp (packet
, "range:", strlen ("range:")) == 0)
3523 packet
+= strlen ("range:");
3524 packet
= unpack_varlen_hex (packet
, &lo
);
3526 unpack_varlen_hex (packet
, &hi
);
3527 trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s",
3528 paddress (lo
), paddress (hi
));
3529 tframe
= find_next_traceframe_in_range (lo
, hi
, 1, &tfnum
);
3531 else if (strncmp (packet
, "outside:", strlen ("outside:")) == 0)
3533 packet
+= strlen ("outside:");
3534 packet
= unpack_varlen_hex (packet
, &lo
);
3536 unpack_varlen_hex (packet
, &hi
);
3537 trace_debug ("Want to find next traceframe "
3538 "outside the range 0x%s to 0x%s",
3539 paddress (lo
), paddress (hi
));
3540 tframe
= find_next_traceframe_in_range (lo
, hi
, 0, &tfnum
);
3542 else if (strncmp (packet
, "tdp:", strlen ("tdp:")) == 0)
3544 packet
+= strlen ("tdp:");
3545 unpack_varlen_hex (packet
, &num
);
3547 trace_debug ("Want to find next traceframe for tracepoint %d", tpnum
);
3548 tframe
= find_next_traceframe_by_tracepoint (tpnum
, &tfnum
);
3552 unpack_varlen_hex (packet
, &frame
);
3553 tfnum
= (int) frame
;
3556 trace_debug ("Want to stop looking at traceframes");
3557 current_traceframe
= -1;
3561 trace_debug ("Want to look at traceframe %d", tfnum
);
3562 tframe
= find_traceframe (tfnum
);
3567 current_traceframe
= tfnum
;
3568 sprintf (own_buf
, "F%xT%x", tfnum
, tframe
->tpnum
);
3571 sprintf (own_buf
, "F-1");
3575 cmd_qtstatus (char *packet
)
3577 char *stop_reason_rsp
= NULL
;
3578 char *buf1
, *buf2
, *buf3
, *str
;
3581 /* Translate the plain text of the notes back into hex for
3584 str
= (tracing_user_name
? tracing_user_name
: "");
3585 slen
= strlen (str
);
3586 buf1
= (char *) alloca (slen
* 2 + 1);
3587 hexify (buf1
, str
, slen
);
3589 str
= (tracing_notes
? tracing_notes
: "");
3590 slen
= strlen (str
);
3591 buf2
= (char *) alloca (slen
* 2 + 1);
3592 hexify (buf2
, str
, slen
);
3594 str
= (tracing_stop_note
? tracing_stop_note
: "");
3595 slen
= strlen (str
);
3596 buf3
= (char *) alloca (slen
* 2 + 1);
3597 hexify (buf3
, str
, slen
);
3599 trace_debug ("Returning trace status as %d, stop reason %s",
3600 tracing
, tracing_stop_reason
);
3602 if (agent_loaded_p ())
3606 upload_fast_traceframes ();
3611 stop_reason_rsp
= (char *) tracing_stop_reason
;
3613 /* The user visible error string in terror needs to be hex encoded.
3614 We leave it as plain string in `tracing_stop_reason' to ease
3616 if (strncmp (stop_reason_rsp
, "terror:", strlen ("terror:")) == 0)
3618 const char *result_name
;
3622 result_name
= stop_reason_rsp
+ strlen ("terror:");
3623 hexstr_len
= strlen (result_name
) * 2;
3624 p
= stop_reason_rsp
= alloca (strlen ("terror:") + hexstr_len
+ 1);
3625 strcpy (p
, "terror:");
3627 convert_int_to_ascii ((gdb_byte
*) result_name
, p
, strlen (result_name
));
3630 /* If this was a forced stop, include any stop note that was supplied. */
3631 if (strcmp (stop_reason_rsp
, "tstop") == 0)
3633 stop_reason_rsp
= alloca (strlen ("tstop:") + strlen (buf3
) + 1);
3634 strcpy (stop_reason_rsp
, "tstop:");
3635 strcat (stop_reason_rsp
, buf3
);
3641 "tframes:%x;tcreated:%x;"
3642 "tfree:%x;tsize:%s;"
3645 "starttime:%s;stoptime:%s;"
3646 "username:%s:;notes:%s:",
3648 stop_reason_rsp
, tracing_stop_tpnum
,
3649 traceframe_count
, traceframes_created
,
3650 free_space (), phex_nz (trace_buffer_hi
- trace_buffer_lo
, 0),
3651 circular_trace_buffer
,
3652 disconnected_tracing
,
3653 plongest (tracing_start_time
), plongest (tracing_stop_time
),
3658 cmd_qtp (char *own_buf
)
3661 struct tracepoint
*tpoint
;
3662 char *packet
= own_buf
;
3664 packet
+= strlen ("qTP:");
3666 packet
= unpack_varlen_hex (packet
, &num
);
3667 ++packet
; /* skip a colon */
3668 packet
= unpack_varlen_hex (packet
, &addr
);
3670 /* See if we already have this tracepoint. */
3671 tpoint
= find_tracepoint (num
, addr
);
3675 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
3676 (int) num
, paddress (addr
));
3677 write_enn (own_buf
);
3681 sprintf (own_buf
, "V%" PRIu64
":%" PRIu64
"", tpoint
->hit_count
,
3682 tpoint
->traceframe_usage
);
3685 /* State variables to help return all the tracepoint bits. */
3686 static struct tracepoint
*cur_tpoint
;
3687 static int cur_action
;
3688 static int cur_step_action
;
3689 static struct source_string
*cur_source_string
;
3690 static struct trace_state_variable
*cur_tsv
;
3692 /* Compose a response that is an imitation of the syntax by which the
3693 tracepoint was originally downloaded. */
3696 response_tracepoint (char *packet
, struct tracepoint
*tpoint
)
3700 sprintf (packet
, "T%x:%s:%c:%" PRIx64
":%" PRIx64
, tpoint
->number
,
3701 paddress (tpoint
->address
),
3702 (tpoint
->enabled
? 'E' : 'D'), tpoint
->step_count
,
3703 tpoint
->pass_count
);
3704 if (tpoint
->type
== fast_tracepoint
)
3705 sprintf (packet
+ strlen (packet
), ":F%x", tpoint
->orig_size
);
3706 else if (tpoint
->type
== static_tracepoint
)
3707 sprintf (packet
+ strlen (packet
), ":S");
3711 buf
= gdb_unparse_agent_expr (tpoint
->cond
);
3712 sprintf (packet
+ strlen (packet
), ":X%x,%s",
3713 tpoint
->cond
->length
, buf
);
3718 /* Compose a response that is an imitation of the syntax by which the
3719 tracepoint action was originally downloaded (with the difference
3720 that due to the way we store the actions, this will output a packet
3721 per action, while GDB could have combined more than one action
3725 response_action (char *packet
, struct tracepoint
*tpoint
,
3726 char *taction
, int step
)
3728 sprintf (packet
, "%c%x:%s:%s",
3729 (step
? 'S' : 'A'), tpoint
->number
, paddress (tpoint
->address
),
3733 /* Compose a response that is an imitation of the syntax by which the
3734 tracepoint source piece was originally downloaded. */
3737 response_source (char *packet
,
3738 struct tracepoint
*tpoint
, struct source_string
*src
)
3743 len
= strlen (src
->str
);
3744 buf
= alloca (len
* 2 + 1);
3745 convert_int_to_ascii ((gdb_byte
*) src
->str
, buf
, len
);
3747 sprintf (packet
, "Z%x:%s:%s:%x:%x:%s",
3748 tpoint
->number
, paddress (tpoint
->address
),
3749 src
->type
, 0, len
, buf
);
3752 /* Return the first piece of tracepoint definition, and initialize the
3753 state machine that will iterate through all the tracepoint
3757 cmd_qtfp (char *packet
)
3759 trace_debug ("Returning first tracepoint definition piece");
3761 cur_tpoint
= tracepoints
;
3762 cur_action
= cur_step_action
= -1;
3763 cur_source_string
= NULL
;
3766 response_tracepoint (packet
, cur_tpoint
);
3768 strcpy (packet
, "l");
3771 /* Return additional pieces of tracepoint definition. Each action and
3772 stepping action must go into its own packet, because of packet size
3773 limits, and so we use state variables to deliver one piece at a
3777 cmd_qtsp (char *packet
)
3779 trace_debug ("Returning subsequent tracepoint definition piece");
3783 /* This case would normally never occur, but be prepared for
3785 strcpy (packet
, "l");
3787 else if (cur_action
< cur_tpoint
->numactions
- 1)
3790 response_action (packet
, cur_tpoint
,
3791 cur_tpoint
->actions_str
[cur_action
], 0);
3793 else if (cur_step_action
< cur_tpoint
->num_step_actions
- 1)
3796 response_action (packet
, cur_tpoint
,
3797 cur_tpoint
->step_actions_str
[cur_step_action
], 1);
3799 else if ((cur_source_string
3800 ? cur_source_string
->next
3801 : cur_tpoint
->source_strings
))
3803 if (cur_source_string
)
3804 cur_source_string
= cur_source_string
->next
;
3806 cur_source_string
= cur_tpoint
->source_strings
;
3807 response_source (packet
, cur_tpoint
, cur_source_string
);
3811 cur_tpoint
= cur_tpoint
->next
;
3812 cur_action
= cur_step_action
= -1;
3813 cur_source_string
= NULL
;
3815 response_tracepoint (packet
, cur_tpoint
);
3817 strcpy (packet
, "l");
3821 /* Compose a response that is an imitation of the syntax by which the
3822 trace state variable was originally downloaded. */
3825 response_tsv (char *packet
, struct trace_state_variable
*tsv
)
3827 char *buf
= (char *) "";
3832 namelen
= strlen (tsv
->name
);
3833 buf
= alloca (namelen
* 2 + 1);
3834 convert_int_to_ascii ((gdb_byte
*) tsv
->name
, buf
, namelen
);
3837 sprintf (packet
, "%x:%s:%x:%s", tsv
->number
, phex_nz (tsv
->initial_value
, 0),
3838 tsv
->getter
? 1 : 0, buf
);
3841 /* Return the first trace state variable definition, and initialize
3842 the state machine that will iterate through all the tsv bits. */
3845 cmd_qtfv (char *packet
)
3847 trace_debug ("Returning first trace state variable definition");
3849 cur_tsv
= trace_state_variables
;
3852 response_tsv (packet
, cur_tsv
);
3854 strcpy (packet
, "l");
3857 /* Return additional trace state variable definitions. */
3860 cmd_qtsv (char *packet
)
3862 trace_debug ("Returning additional trace state variable definition");
3866 cur_tsv
= cur_tsv
->next
;
3868 response_tsv (packet
, cur_tsv
);
3870 strcpy (packet
, "l");
3873 strcpy (packet
, "l");
3876 /* Return the first static tracepoint marker, and initialize the state
3877 machine that will iterate through all the static tracepoints
3881 cmd_qtfstm (char *packet
)
3883 if (!maybe_write_ipa_ust_not_loaded (packet
))
3884 run_inferior_command (packet
, strlen (packet
) + 1);
3887 /* Return additional static tracepoints markers. */
3890 cmd_qtsstm (char *packet
)
3892 if (!maybe_write_ipa_ust_not_loaded (packet
))
3893 run_inferior_command (packet
, strlen (packet
) + 1);
3896 /* Return the definition of the static tracepoint at a given address.
3897 Result packet is the same as qTsST's. */
3900 cmd_qtstmat (char *packet
)
3902 if (!maybe_write_ipa_ust_not_loaded (packet
))
3903 run_inferior_command (packet
, strlen (packet
) + 1);
3906 /* Sent the agent a command to close it. */
3909 gdb_agent_about_to_close (int pid
)
3911 char buf
[IPA_CMD_BUF_SIZE
];
3913 if (!maybe_write_ipa_not_loaded (buf
))
3915 struct thread_info
*save_inferior
;
3916 struct inferior_list_entry
*inf
= all_threads
.head
;
3918 save_inferior
= current_inferior
;
3920 /* Find a certain thread which belongs to process PID. */
3923 if (ptid_get_pid (inf
->id
) == pid
)
3928 current_inferior
= (struct thread_info
*) inf
;
3930 strcpy (buf
, "close");
3932 run_inferior_command (buf
, strlen (buf
) + 1);
3934 current_inferior
= save_inferior
;
3938 /* Return the minimum instruction size needed for fast tracepoints as a
3939 hexadecimal number. */
3942 cmd_qtminftpilen (char *packet
)
3944 if (current_inferior
== NULL
)
3946 /* Indicate that the minimum length is currently unknown. */
3947 strcpy (packet
, "0");
3951 sprintf (packet
, "%x", target_get_min_fast_tracepoint_insn_len ());
3954 /* Respond to qTBuffer packet with a block of raw data from the trace
3955 buffer. GDB may ask for a lot, but we are allowed to reply with
3956 only as much as will fit within packet limits or whatever. */
3959 cmd_qtbuffer (char *own_buf
)
3961 ULONGEST offset
, num
, tot
;
3963 char *packet
= own_buf
;
3965 packet
+= strlen ("qTBuffer:");
3967 packet
= unpack_varlen_hex (packet
, &offset
);
3968 ++packet
; /* skip a comma */
3969 unpack_varlen_hex (packet
, &num
);
3971 trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s",
3972 (int) num
, phex_nz (offset
, 0));
3974 tot
= (trace_buffer_hi
- trace_buffer_lo
) - free_space ();
3976 /* If we're right at the end, reply specially that we're done. */
3979 strcpy (own_buf
, "l");
3983 /* Object to any other out-of-bounds request. */
3986 write_enn (own_buf
);
3990 /* Compute the pointer corresponding to the given offset, accounting
3992 tbp
= trace_buffer_start
+ offset
;
3993 if (tbp
>= trace_buffer_wrap
)
3994 tbp
-= (trace_buffer_wrap
- trace_buffer_lo
);
3996 /* Trim to the remaining bytes if we're close to the end. */
3997 if (num
> tot
- offset
)
4000 /* Trim to available packet size. */
4001 if (num
>= (PBUFSIZ
- 16) / 2 )
4002 num
= (PBUFSIZ
- 16) / 2;
4004 convert_int_to_ascii (tbp
, own_buf
, num
);
4008 cmd_bigqtbuffer_circular (char *own_buf
)
4011 char *packet
= own_buf
;
4013 packet
+= strlen ("QTBuffer:circular:");
4015 unpack_varlen_hex (packet
, &val
);
4016 circular_trace_buffer
= val
;
4017 trace_debug ("Trace buffer is now %s",
4018 circular_trace_buffer
? "circular" : "linear");
4023 cmd_qtnotes (char *own_buf
)
4026 char *saved
, *user
, *notes
, *stopnote
;
4027 char *packet
= own_buf
;
4029 packet
+= strlen ("QTNotes:");
4033 if (strncmp ("user:", packet
, strlen ("user:")) == 0)
4035 packet
+= strlen ("user:");
4037 packet
= strchr (packet
, ';');
4038 nbytes
= (packet
- saved
) / 2;
4039 user
= xmalloc (nbytes
+ 1);
4040 nbytes
= unhexify (user
, saved
, nbytes
);
4041 user
[nbytes
] = '\0';
4042 ++packet
; /* skip the semicolon */
4043 trace_debug ("User is '%s'", user
);
4044 xfree (tracing_user_name
);
4045 tracing_user_name
= user
;
4047 else if (strncmp ("notes:", packet
, strlen ("notes:")) == 0)
4049 packet
+= strlen ("notes:");
4051 packet
= strchr (packet
, ';');
4052 nbytes
= (packet
- saved
) / 2;
4053 notes
= xmalloc (nbytes
+ 1);
4054 nbytes
= unhexify (notes
, saved
, nbytes
);
4055 notes
[nbytes
] = '\0';
4056 ++packet
; /* skip the semicolon */
4057 trace_debug ("Notes is '%s'", notes
);
4058 xfree (tracing_notes
);
4059 tracing_notes
= notes
;
4061 else if (strncmp ("tstop:", packet
, strlen ("tstop:")) == 0)
4063 packet
+= strlen ("tstop:");
4065 packet
= strchr (packet
, ';');
4066 nbytes
= (packet
- saved
) / 2;
4067 stopnote
= xmalloc (nbytes
+ 1);
4068 nbytes
= unhexify (stopnote
, saved
, nbytes
);
4069 stopnote
[nbytes
] = '\0';
4070 ++packet
; /* skip the semicolon */
4071 trace_debug ("tstop note is '%s'", stopnote
);
4072 xfree (tracing_stop_note
);
4073 tracing_stop_note
= stopnote
;
4083 handle_tracepoint_general_set (char *packet
)
4085 if (strcmp ("QTinit", packet
) == 0)
4087 cmd_qtinit (packet
);
4090 else if (strncmp ("QTDP:", packet
, strlen ("QTDP:")) == 0)
4095 else if (strncmp ("QTDPsrc:", packet
, strlen ("QTDPsrc:")) == 0)
4097 cmd_qtdpsrc (packet
);
4100 else if (strncmp ("QTEnable:", packet
, strlen ("QTEnable:")) == 0)
4102 cmd_qtenable_disable (packet
, 1);
4105 else if (strncmp ("QTDisable:", packet
, strlen ("QTDisable:")) == 0)
4107 cmd_qtenable_disable (packet
, 0);
4110 else if (strncmp ("QTDV:", packet
, strlen ("QTDV:")) == 0)
4115 else if (strncmp ("QTro:", packet
, strlen ("QTro:")) == 0)
4120 else if (strcmp ("QTStart", packet
) == 0)
4122 cmd_qtstart (packet
);
4125 else if (strcmp ("QTStop", packet
) == 0)
4127 cmd_qtstop (packet
);
4130 else if (strncmp ("QTDisconnected:", packet
,
4131 strlen ("QTDisconnected:")) == 0)
4133 cmd_qtdisconnected (packet
);
4136 else if (strncmp ("QTFrame:", packet
, strlen ("QTFrame:")) == 0)
4138 cmd_qtframe (packet
);
4141 else if (strncmp ("QTBuffer:circular:", packet
, strlen ("QTBuffer:circular:")) == 0)
4143 cmd_bigqtbuffer_circular (packet
);
4146 else if (strncmp ("QTNotes:", packet
, strlen ("QTNotes:")) == 0)
4148 cmd_qtnotes (packet
);
4156 handle_tracepoint_query (char *packet
)
4158 if (strcmp ("qTStatus", packet
) == 0)
4160 cmd_qtstatus (packet
);
4163 else if (strncmp ("qTP:", packet
, strlen ("qTP:")) == 0)
4168 else if (strcmp ("qTfP", packet
) == 0)
4173 else if (strcmp ("qTsP", packet
) == 0)
4178 else if (strcmp ("qTfV", packet
) == 0)
4183 else if (strcmp ("qTsV", packet
) == 0)
4188 else if (strncmp ("qTV:", packet
, strlen ("qTV:")) == 0)
4193 else if (strncmp ("qTBuffer:", packet
, strlen ("qTBuffer:")) == 0)
4195 cmd_qtbuffer (packet
);
4198 else if (strcmp ("qTfSTM", packet
) == 0)
4200 cmd_qtfstm (packet
);
4203 else if (strcmp ("qTsSTM", packet
) == 0)
4205 cmd_qtsstm (packet
);
4208 else if (strncmp ("qTSTMat:", packet
, strlen ("qTSTMat:")) == 0)
4210 cmd_qtstmat (packet
);
4213 else if (strcmp ("qTMinFTPILen", packet
) == 0)
4215 cmd_qtminftpilen (packet
);
4223 #ifndef IN_PROCESS_AGENT
4225 /* Call this when thread TINFO has hit the tracepoint defined by
4226 TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping
4227 action. This adds a while-stepping collecting state item to the
4228 threads' collecting state list, so that we can keep track of
4229 multiple simultaneous while-stepping actions being collected by the
4230 same thread. This can happen in cases like:
4232 ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs
4234 ff0003 INSN3 <-- TP2, collect $regs
4235 ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs
4238 Notice that when instruction INSN5 is reached, the while-stepping
4239 actions of both TP1 and TP3 are still being collected, and that TP2
4240 had been collected meanwhile. The whole range of ff0001-ff0005
4241 should be single-stepped, due to at least TP1's while-stepping
4242 action covering the whole range. */
4245 add_while_stepping_state (struct thread_info
*tinfo
,
4246 int tp_number
, CORE_ADDR tp_address
)
4248 struct wstep_state
*wstep
;
4250 wstep
= xmalloc (sizeof (*wstep
));
4251 wstep
->next
= tinfo
->while_stepping
;
4253 wstep
->tp_number
= tp_number
;
4254 wstep
->tp_address
= tp_address
;
4255 wstep
->current_step
= 0;
4257 tinfo
->while_stepping
= wstep
;
4260 /* Release the while-stepping collecting state WSTEP. */
4263 release_while_stepping_state (struct wstep_state
*wstep
)
4268 /* Release all while-stepping collecting states currently associated
4269 with thread TINFO. */
4272 release_while_stepping_state_list (struct thread_info
*tinfo
)
4274 struct wstep_state
*head
;
4276 while (tinfo
->while_stepping
)
4278 head
= tinfo
->while_stepping
;
4279 tinfo
->while_stepping
= head
->next
;
4280 release_while_stepping_state (head
);
4284 /* If TINFO was handling a 'while-stepping' action, the step has
4285 finished, so collect any step data needed, and check if any more
4286 steps are required. Return true if the thread was indeed
4287 collecting tracepoint data, false otherwise. */
4290 tracepoint_finished_step (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4292 struct tracepoint
*tpoint
;
4293 struct wstep_state
*wstep
;
4294 struct wstep_state
**wstep_link
;
4295 struct trap_tracepoint_ctx ctx
;
4297 /* Pull in fast tracepoint trace frames from the inferior lib buffer into
4299 if (agent_loaded_p ())
4300 upload_fast_traceframes ();
4302 /* Check if we were indeed collecting data for one of more
4303 tracepoints with a 'while-stepping' count. */
4304 if (tinfo
->while_stepping
== NULL
)
4309 /* We're not even tracing anymore. Stop this thread from
4311 release_while_stepping_state_list (tinfo
);
4313 /* The thread had stopped due to a single-step request indeed
4314 explained by a tracepoint. */
4318 wstep
= tinfo
->while_stepping
;
4319 wstep_link
= &tinfo
->while_stepping
;
4321 trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
4322 target_pid_to_str (tinfo
->entry
.id
),
4323 wstep
->tp_number
, paddress (wstep
->tp_address
));
4325 ctx
.base
.type
= trap_tracepoint
;
4326 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4328 while (wstep
!= NULL
)
4330 tpoint
= find_tracepoint (wstep
->tp_number
, wstep
->tp_address
);
4333 trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
4334 wstep
->tp_number
, paddress (wstep
->tp_address
),
4335 target_pid_to_str (tinfo
->entry
.id
));
4338 *wstep_link
= wstep
->next
;
4339 release_while_stepping_state (wstep
);
4340 wstep
= *wstep_link
;
4344 /* We've just finished one step. */
4345 ++wstep
->current_step
;
4348 collect_data_at_step ((struct tracepoint_hit_ctx
*) &ctx
,
4349 stop_pc
, tpoint
, wstep
->current_step
);
4351 if (wstep
->current_step
>= tpoint
->step_count
)
4353 /* The requested numbers of steps have occurred. */
4354 trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
4355 target_pid_to_str (tinfo
->entry
.id
),
4356 wstep
->tp_number
, paddress (wstep
->tp_address
));
4358 /* Unlink the wstep. */
4359 *wstep_link
= wstep
->next
;
4360 release_while_stepping_state (wstep
);
4361 wstep
= *wstep_link
;
4363 /* Only check the hit count now, which ensure that we do all
4364 our stepping before stopping the run. */
4365 if (tpoint
->pass_count
> 0
4366 && tpoint
->hit_count
>= tpoint
->pass_count
4367 && stopping_tracepoint
== NULL
)
4368 stopping_tracepoint
= tpoint
;
4372 /* Keep single-stepping until the requested numbers of steps
4374 wstep_link
= &wstep
->next
;
4375 wstep
= *wstep_link
;
4378 if (stopping_tracepoint
4379 || trace_buffer_is_full
4380 || expr_eval_result
!= expr_eval_no_error
)
4390 /* Handle any internal tracing control breakpoint hits. That means,
4391 pull traceframes from the IPA to our buffer, and syncing both
4392 tracing agents when the IPA's tracing stops for some reason. */
4395 handle_tracepoint_bkpts (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4397 /* Pull in fast tracepoint trace frames from the inferior in-process
4398 agent's buffer into our buffer. */
4400 if (!agent_loaded_p ())
4403 upload_fast_traceframes ();
4405 /* Check if the in-process agent had decided we should stop
4407 if (stop_pc
== ipa_sym_addrs
.addr_stop_tracing
)
4409 int ipa_trace_buffer_is_full
;
4410 CORE_ADDR ipa_stopping_tracepoint
;
4411 int ipa_expr_eval_result
;
4412 CORE_ADDR ipa_error_tracepoint
;
4414 trace_debug ("lib stopped at stop_tracing");
4416 read_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
,
4417 &ipa_trace_buffer_is_full
);
4419 read_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
4420 &ipa_stopping_tracepoint
);
4421 write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
, 0);
4423 read_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
,
4424 &ipa_error_tracepoint
);
4425 write_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
, 0);
4427 read_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
,
4428 &ipa_expr_eval_result
);
4429 write_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
, 0);
4431 trace_debug ("lib: trace_buffer_is_full: %d, "
4432 "stopping_tracepoint: %s, "
4433 "ipa_expr_eval_result: %d, "
4434 "error_tracepoint: %s, ",
4435 ipa_trace_buffer_is_full
,
4436 paddress (ipa_stopping_tracepoint
),
4437 ipa_expr_eval_result
,
4438 paddress (ipa_error_tracepoint
));
4442 if (ipa_trace_buffer_is_full
)
4443 trace_debug ("lib stopped due to full buffer.");
4444 if (ipa_stopping_tracepoint
)
4445 trace_debug ("lib stopped due to tpoint");
4446 if (ipa_stopping_tracepoint
)
4447 trace_debug ("lib stopped due to error");
4450 if (ipa_stopping_tracepoint
!= 0)
4453 = fast_tracepoint_from_ipa_tpoint_address (ipa_stopping_tracepoint
);
4455 else if (ipa_expr_eval_result
!= expr_eval_no_error
)
4457 expr_eval_result
= ipa_expr_eval_result
;
4459 = fast_tracepoint_from_ipa_tpoint_address (ipa_error_tracepoint
);
4464 else if (stop_pc
== ipa_sym_addrs
.addr_flush_trace_buffer
)
4466 trace_debug ("lib stopped at flush_trace_buffer");
4473 /* Return true if TINFO just hit a tracepoint. Collect data if
4477 tracepoint_was_hit (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4479 struct tracepoint
*tpoint
;
4481 struct trap_tracepoint_ctx ctx
;
4483 /* Not tracing, don't handle. */
4487 ctx
.base
.type
= trap_tracepoint
;
4488 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4490 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
4492 /* Note that we collect fast tracepoints here as well. We'll
4493 step over the fast tracepoint jump later, which avoids the
4494 double collect. However, we don't collect for static
4495 tracepoints here, because UST markers are compiled in program,
4496 and probes will be executed in program. So static tracepoints
4497 are collected there. */
4498 if (tpoint
->enabled
&& stop_pc
== tpoint
->address
4499 && tpoint
->type
!= static_tracepoint
)
4501 trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
4502 target_pid_to_str (tinfo
->entry
.id
),
4503 tpoint
->number
, paddress (tpoint
->address
));
4505 /* Test the condition if present, and collect if true. */
4507 || (condition_true_at_tracepoint
4508 ((struct tracepoint_hit_ctx
*) &ctx
, tpoint
)))
4509 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
4512 if (stopping_tracepoint
4513 || trace_buffer_is_full
4514 || expr_eval_result
!= expr_eval_no_error
)
4518 /* If the tracepoint had a 'while-stepping' action, then set
4519 the thread to collect this tracepoint on the following
4521 else if (tpoint
->step_count
> 0)
4523 add_while_stepping_state (tinfo
,
4524 tpoint
->number
, tpoint
->address
);
4536 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4537 struct ust_marker_data
;
4538 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4539 struct traceframe
*tframe
);
4542 /* Create a trace frame for the hit of the given tracepoint in the
4546 collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
, CORE_ADDR stop_pc
,
4547 struct tracepoint
*tpoint
)
4549 struct traceframe
*tframe
;
4552 /* Only count it as a hit when we actually collect data. */
4553 tpoint
->hit_count
++;
4555 /* If we've exceeded a defined pass count, record the event for
4556 later, and finish the collection for this hit. This test is only
4557 for nonstepping tracepoints, stepping tracepoints test at the end
4558 of their while-stepping loop. */
4559 if (tpoint
->pass_count
> 0
4560 && tpoint
->hit_count
>= tpoint
->pass_count
4561 && tpoint
->step_count
== 0
4562 && stopping_tracepoint
== NULL
)
4563 stopping_tracepoint
= tpoint
;
4565 trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64
,
4566 tpoint
->number
, paddress (tpoint
->address
), tpoint
->hit_count
);
4568 tframe
= add_traceframe (tpoint
);
4572 for (acti
= 0; acti
< tpoint
->numactions
; ++acti
)
4574 #ifndef IN_PROCESS_AGENT
4575 trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
4576 tpoint
->number
, paddress (tpoint
->address
),
4577 tpoint
->actions_str
[acti
]);
4580 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4581 tpoint
->actions
[acti
]);
4584 finish_traceframe (tframe
);
4587 if (tframe
== NULL
&& tracing
)
4588 trace_buffer_is_full
= 1;
4591 #ifndef IN_PROCESS_AGENT
4594 collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
4596 struct tracepoint
*tpoint
, int current_step
)
4598 struct traceframe
*tframe
;
4601 trace_debug ("Making new step traceframe for "
4602 "tracepoint %d at 0x%s, step %d of %" PRIu64
", hit %" PRIu64
,
4603 tpoint
->number
, paddress (tpoint
->address
),
4604 current_step
, tpoint
->step_count
,
4607 tframe
= add_traceframe (tpoint
);
4611 for (acti
= 0; acti
< tpoint
->num_step_actions
; ++acti
)
4613 trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'",
4614 tpoint
->number
, paddress (tpoint
->address
),
4615 tpoint
->step_actions_str
[acti
]);
4617 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4618 tpoint
->step_actions
[acti
]);
4621 finish_traceframe (tframe
);
4624 if (tframe
== NULL
&& tracing
)
4625 trace_buffer_is_full
= 1;
4630 static struct regcache
*
4631 get_context_regcache (struct tracepoint_hit_ctx
*ctx
)
4633 struct regcache
*regcache
= NULL
;
4635 #ifdef IN_PROCESS_AGENT
4636 if (ctx
->type
== fast_tracepoint
)
4638 struct fast_tracepoint_ctx
*fctx
= (struct fast_tracepoint_ctx
*) ctx
;
4639 if (!fctx
->regcache_initted
)
4641 fctx
->regcache_initted
= 1;
4642 init_register_cache (&fctx
->regcache
, fctx
->regspace
);
4643 supply_regblock (&fctx
->regcache
, NULL
);
4644 supply_fast_tracepoint_registers (&fctx
->regcache
, fctx
->regs
);
4646 regcache
= &fctx
->regcache
;
4649 if (ctx
->type
== static_tracepoint
)
4651 struct static_tracepoint_ctx
*sctx
4652 = (struct static_tracepoint_ctx
*) ctx
;
4654 if (!sctx
->regcache_initted
)
4656 sctx
->regcache_initted
= 1;
4657 init_register_cache (&sctx
->regcache
, sctx
->regspace
);
4658 supply_regblock (&sctx
->regcache
, NULL
);
4659 /* Pass down the tracepoint address, because REGS doesn't
4660 include the PC, but we know what it must have been. */
4661 supply_static_tracepoint_registers (&sctx
->regcache
,
4662 (const unsigned char *)
4664 sctx
->tpoint
->address
);
4666 regcache
= &sctx
->regcache
;
4670 if (ctx
->type
== trap_tracepoint
)
4672 struct trap_tracepoint_ctx
*tctx
= (struct trap_tracepoint_ctx
*) ctx
;
4673 regcache
= tctx
->regcache
;
4677 gdb_assert (regcache
!= NULL
);
4683 do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4685 struct tracepoint
*tpoint
,
4686 struct traceframe
*tframe
,
4687 struct tracepoint_action
*taction
)
4689 enum eval_result_type err
;
4691 switch (taction
->type
)
4695 struct collect_memory_action
*maction
;
4696 struct eval_agent_expr_context ax_ctx
;
4698 maction
= (struct collect_memory_action
*) taction
;
4699 ax_ctx
.regcache
= NULL
;
4700 ax_ctx
.tframe
= tframe
;
4701 ax_ctx
.tpoint
= tpoint
;
4703 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
4704 pulongest (maction
->len
),
4705 paddress (maction
->addr
), maction
->basereg
);
4706 /* (should use basereg) */
4707 agent_mem_read (&ax_ctx
, NULL
, (CORE_ADDR
) maction
->addr
,
4713 unsigned char *regspace
;
4714 struct regcache tregcache
;
4715 struct regcache
*context_regcache
;
4718 trace_debug ("Want to collect registers");
4720 /* Collect all registers for now. */
4721 regspace
= add_traceframe_block (tframe
, tpoint
,
4722 1 + register_cache_size ());
4723 if (regspace
== NULL
)
4725 trace_debug ("Trace buffer block allocation failed, skipping");
4728 /* Identify a register block. */
4731 context_regcache
= get_context_regcache (ctx
);
4733 /* Wrap the regblock in a register cache (in the stack, we
4734 don't want to malloc here). */
4735 init_register_cache (&tregcache
, regspace
+ 1);
4737 /* Copy the register data to the regblock. */
4738 regcache_cpy (&tregcache
, context_regcache
);
4740 #ifndef IN_PROCESS_AGENT
4741 /* On some platforms, trap-based tracepoints will have the PC
4742 pointing to the next instruction after the trap, but we
4743 don't want the user or GDB trying to guess whether the
4744 saved PC needs adjusting; so always record the adjusted
4745 stop_pc. Note that we can't use tpoint->address instead,
4746 since it will be wrong for while-stepping actions. This
4747 adjustment is a nop for fast tracepoints collected from the
4748 in-process lib (but not if GDBserver is collecting one
4749 preemptively), since the PC had already been adjusted to
4750 contain the tracepoint's address by the jump pad. */
4751 trace_debug ("Storing stop pc (0x%s) in regblock",
4752 paddress (stop_pc
));
4754 /* This changes the regblock, not the thread's
4756 regcache_write_pc (&tregcache
, stop_pc
);
4762 struct eval_expr_action
*eaction
;
4763 struct eval_agent_expr_context ax_ctx
;
4765 eaction
= (struct eval_expr_action
*) taction
;
4766 ax_ctx
.regcache
= get_context_regcache (ctx
);
4767 ax_ctx
.tframe
= tframe
;
4768 ax_ctx
.tpoint
= tpoint
;
4770 trace_debug ("Want to evaluate expression");
4772 err
= gdb_eval_agent_expr (&ax_ctx
, eaction
->expr
, NULL
);
4774 if (err
!= expr_eval_no_error
)
4776 record_tracepoint_error (tpoint
, "action expression", err
);
4783 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4784 trace_debug ("Want to collect static trace data");
4785 collect_ust_data_at_tracepoint (ctx
, tframe
);
4787 trace_debug ("warning: collecting static trace data, "
4788 "but static tracepoints are not supported");
4793 trace_debug ("unknown trace action '%c', ignoring", taction
->type
);
4799 condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4800 struct tracepoint
*tpoint
)
4803 enum eval_result_type err
;
4805 /* Presently, gdbserver doesn't run compiled conditions, only the
4806 IPA does. If the program stops at a fast tracepoint's address
4807 (e.g., due to a breakpoint, trap tracepoint, or stepping),
4808 gdbserver preemptively collect the fast tracepoint. Later, on
4809 resume, gdbserver steps over the fast tracepoint like it steps
4810 over breakpoints, so that the IPA doesn't see that fast
4811 tracepoint. This avoids double collects of fast tracepoints in
4812 that stopping scenario. Having gdbserver itself handle the fast
4813 tracepoint gives the user a consistent view of when fast or trap
4814 tracepoints are collected, compared to an alternative where only
4815 trap tracepoints are collected on stop, and fast tracepoints on
4816 resume. When a fast tracepoint is being processed by gdbserver,
4817 it is always the non-compiled condition expression that is
4819 #ifdef IN_PROCESS_AGENT
4820 if (tpoint
->compiled_cond
)
4821 err
= ((condfn
) (uintptr_t) (tpoint
->compiled_cond
)) (ctx
, &value
);
4825 struct eval_agent_expr_context ax_ctx
;
4827 ax_ctx
.regcache
= get_context_regcache (ctx
);
4828 ax_ctx
.tframe
= NULL
;
4829 ax_ctx
.tpoint
= tpoint
;
4831 err
= gdb_eval_agent_expr (&ax_ctx
, tpoint
->cond
, &value
);
4833 if (err
!= expr_eval_no_error
)
4835 record_tracepoint_error (tpoint
, "condition", err
);
4836 /* The error case must return false. */
4840 trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
4841 tpoint
->number
, paddress (tpoint
->address
),
4843 return (value
? 1 : 0);
4846 /* Do memory copies for bytecodes. */
4847 /* Do the recording of memory blocks for actions and bytecodes. */
4850 agent_mem_read (struct eval_agent_expr_context
*ctx
,
4851 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4853 unsigned char *mspace
;
4854 ULONGEST remaining
= len
;
4855 unsigned short blocklen
;
4857 /* If a 'to' buffer is specified, use it. */
4860 read_inferior_memory (from
, to
, len
);
4864 /* Otherwise, create a new memory block in the trace buffer. */
4865 while (remaining
> 0)
4869 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4870 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
4871 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
4874 /* Identify block as a memory block. */
4877 /* Record address and size. */
4878 memcpy (mspace
, &from
, sizeof (from
));
4879 mspace
+= sizeof (from
);
4880 memcpy (mspace
, &blocklen
, sizeof (blocklen
));
4881 mspace
+= sizeof (blocklen
);
4882 /* Record the memory block proper. */
4883 read_inferior_memory (from
, mspace
, blocklen
);
4884 trace_debug ("%d bytes recorded", blocklen
);
4885 remaining
-= blocklen
;
4892 agent_mem_read_string (struct eval_agent_expr_context
*ctx
,
4893 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4895 unsigned char *buf
, *mspace
;
4896 ULONGEST remaining
= len
;
4897 unsigned short blocklen
, i
;
4899 /* To save a bit of space, block lengths are 16-bit, so break large
4900 requests into multiple blocks. Bordering on overkill for strings,
4901 but it could happen that someone specifies a large max length. */
4902 while (remaining
> 0)
4906 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4907 /* We want working space to accumulate nonzero bytes, since
4908 traceframes must have a predecided size (otherwise it gets
4909 harder to wrap correctly for the circular case, etc). */
4910 buf
= (unsigned char *) xmalloc (blocklen
+ 1);
4911 for (i
= 0; i
< blocklen
; ++i
)
4913 /* Read the string one byte at a time, in case the string is
4914 at the end of a valid memory area - we don't want a
4915 correctly-terminated string to engender segvio
4917 read_inferior_memory (from
+ i
, buf
+ i
, 1);
4922 /* Make sure outer loop stops now too. */
4923 remaining
= blocklen
;
4927 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
4928 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
4934 /* Identify block as a memory block. */
4937 /* Record address and size. */
4938 memcpy ((void *) mspace
, (void *) &from
, sizeof (from
));
4939 mspace
+= sizeof (from
);
4940 memcpy ((void *) mspace
, (void *) &blocklen
, sizeof (blocklen
));
4941 mspace
+= sizeof (blocklen
);
4942 /* Copy the string contents. */
4943 memcpy ((void *) mspace
, (void *) buf
, blocklen
);
4944 remaining
-= blocklen
;
4951 /* Record the value of a trace state variable. */
4954 agent_tsv_read (struct eval_agent_expr_context
*ctx
, int n
)
4956 unsigned char *vspace
;
4959 vspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
,
4960 1 + sizeof (n
) + sizeof (LONGEST
));
4963 /* Identify block as a variable. */
4965 /* Record variable's number and value. */
4966 memcpy (vspace
+ 1, &n
, sizeof (n
));
4967 val
= get_trace_state_variable_value (n
);
4968 memcpy (vspace
+ 1 + sizeof (n
), &val
, sizeof (val
));
4969 trace_debug ("Variable %d recorded", n
);
4973 #ifndef IN_PROCESS_AGENT
4975 /* Callback for traceframe_walk_blocks, used to find a given block
4976 type in a traceframe. */
4979 match_blocktype (char blocktype
, unsigned char *dataptr
, void *data
)
4981 char *wantedp
= data
;
4983 if (*wantedp
== blocktype
)
4989 /* Walk over all traceframe blocks of the traceframe buffer starting
4990 at DATABASE, of DATASIZE bytes long, and call CALLBACK for each
4991 block found, passing in DATA unmodified. If CALLBACK returns true,
4992 this returns a pointer to where the block is found. Returns NULL
4993 if no callback call returned true, indicating that all blocks have
4996 static unsigned char *
4997 traceframe_walk_blocks (unsigned char *database
, unsigned int datasize
,
4999 int (*callback
) (char blocktype
,
5000 unsigned char *dataptr
,
5004 unsigned char *dataptr
;
5008 trace_debug ("traceframe %d has no data", tfnum
);
5012 /* Iterate through a traceframe's blocks, looking for a block of the
5014 for (dataptr
= database
;
5015 dataptr
< database
+ datasize
;
5019 unsigned short mlen
;
5021 if (dataptr
== trace_buffer_wrap
)
5023 /* Adjust to reflect wrapping part of the frame around to
5025 datasize
= dataptr
- database
;
5026 dataptr
= database
= trace_buffer_lo
;
5029 blocktype
= *dataptr
++;
5031 if ((*callback
) (blocktype
, dataptr
, data
))
5037 /* Skip over the registers block. */
5038 dataptr
+= register_cache_size ();
5041 /* Skip over the memory block. */
5042 dataptr
+= sizeof (CORE_ADDR
);
5043 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5044 dataptr
+= (sizeof (mlen
) + mlen
);
5047 /* Skip over the TSV block. */
5048 dataptr
+= (sizeof (int) + sizeof (LONGEST
));
5051 /* Skip over the static trace data block. */
5052 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5053 dataptr
+= (sizeof (mlen
) + mlen
);
5056 trace_debug ("traceframe %d has unknown block type 0x%x",
5065 /* Look for the block of type TYPE_WANTED in the trameframe starting
5066 at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
5069 static unsigned char *
5070 traceframe_find_block_type (unsigned char *database
, unsigned int datasize
,
5071 int tfnum
, char type_wanted
)
5073 return traceframe_walk_blocks (database
, datasize
, tfnum
,
5074 match_blocktype
, &type_wanted
);
5077 static unsigned char *
5078 traceframe_find_regblock (struct traceframe
*tframe
, int tfnum
)
5080 unsigned char *regblock
;
5082 regblock
= traceframe_find_block_type (tframe
->data
,
5086 if (regblock
== NULL
)
5087 trace_debug ("traceframe %d has no register data", tfnum
);
5092 /* Get registers from a traceframe. */
5095 fetch_traceframe_registers (int tfnum
, struct regcache
*regcache
, int regnum
)
5097 unsigned char *dataptr
;
5098 struct tracepoint
*tpoint
;
5099 struct traceframe
*tframe
;
5101 tframe
= find_traceframe (tfnum
);
5105 trace_debug ("traceframe %d not found", tfnum
);
5109 dataptr
= traceframe_find_regblock (tframe
, tfnum
);
5110 if (dataptr
== NULL
)
5112 /* Mark registers unavailable. */
5113 supply_regblock (regcache
, NULL
);
5115 /* We can generally guess at a PC, although this will be
5116 misleading for while-stepping frames and multi-location
5118 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
5120 regcache_write_pc (regcache
, tpoint
->address
);
5123 supply_regblock (regcache
, dataptr
);
5129 traceframe_get_pc (struct traceframe
*tframe
)
5131 struct regcache regcache
;
5132 unsigned char *dataptr
;
5134 dataptr
= traceframe_find_regblock (tframe
, -1);
5135 if (dataptr
== NULL
)
5138 init_register_cache (®cache
, dataptr
);
5139 return regcache_read_pc (®cache
);
5142 /* Read a requested block of memory from a trace frame. */
5145 traceframe_read_mem (int tfnum
, CORE_ADDR addr
,
5146 unsigned char *buf
, ULONGEST length
,
5149 struct traceframe
*tframe
;
5150 unsigned char *database
, *dataptr
;
5151 unsigned int datasize
;
5153 unsigned short mlen
;
5155 trace_debug ("traceframe_read_mem");
5157 tframe
= find_traceframe (tfnum
);
5161 trace_debug ("traceframe %d not found", tfnum
);
5165 datasize
= tframe
->data_size
;
5166 database
= dataptr
= &tframe
->data
[0];
5168 /* Iterate through a traceframe's blocks, looking for memory. */
5169 while ((dataptr
= traceframe_find_block_type (dataptr
,
5171 - (dataptr
- database
),
5172 tfnum
, 'M')) != NULL
)
5174 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5175 dataptr
+= sizeof (maddr
);
5176 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5177 dataptr
+= sizeof (mlen
);
5178 trace_debug ("traceframe %d has %d bytes at %s",
5179 tfnum
, mlen
, paddress (maddr
));
5181 /* If the block includes the first part of the desired range,
5182 return as much it has; GDB will re-request the remainder,
5183 which might be in a different block of this trace frame. */
5184 if (maddr
<= addr
&& addr
< (maddr
+ mlen
))
5186 ULONGEST amt
= (maddr
+ mlen
) - addr
;
5190 memcpy (buf
, dataptr
+ (addr
- maddr
), amt
);
5195 /* Skip over this block. */
5199 trace_debug ("traceframe %d has no memory data for the desired region",
5207 traceframe_read_tsv (int tsvnum
, LONGEST
*val
)
5210 struct traceframe
*tframe
;
5211 unsigned char *database
, *dataptr
;
5212 unsigned int datasize
;
5215 trace_debug ("traceframe_read_tsv");
5217 tfnum
= current_traceframe
;
5221 trace_debug ("no current traceframe");
5225 tframe
= find_traceframe (tfnum
);
5229 trace_debug ("traceframe %d not found", tfnum
);
5233 datasize
= tframe
->data_size
;
5234 database
= dataptr
= &tframe
->data
[0];
5236 /* Iterate through a traceframe's blocks, looking for the tsv. */
5237 while ((dataptr
= traceframe_find_block_type (dataptr
,
5239 - (dataptr
- database
),
5240 tfnum
, 'V')) != NULL
)
5242 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5243 dataptr
+= sizeof (vnum
);
5245 trace_debug ("traceframe %d has variable %d", tfnum
, vnum
);
5247 /* Check that this is the variable we want. */
5250 memcpy (val
, dataptr
, sizeof (*val
));
5254 /* Skip over this block. */
5255 dataptr
+= sizeof (LONGEST
);
5258 trace_debug ("traceframe %d has no data for variable %d",
5263 /* Read a requested block of static tracepoint data from a trace
5267 traceframe_read_sdata (int tfnum
, ULONGEST offset
,
5268 unsigned char *buf
, ULONGEST length
,
5271 struct traceframe
*tframe
;
5272 unsigned char *database
, *dataptr
;
5273 unsigned int datasize
;
5274 unsigned short mlen
;
5276 trace_debug ("traceframe_read_sdata");
5278 tframe
= find_traceframe (tfnum
);
5282 trace_debug ("traceframe %d not found", tfnum
);
5286 datasize
= tframe
->data_size
;
5287 database
= &tframe
->data
[0];
5289 /* Iterate through a traceframe's blocks, looking for static
5291 dataptr
= traceframe_find_block_type (database
, datasize
,
5293 if (dataptr
!= NULL
)
5295 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5296 dataptr
+= sizeof (mlen
);
5299 if (offset
+ length
> mlen
)
5300 length
= mlen
- offset
;
5302 memcpy (buf
, dataptr
, length
);
5310 trace_debug ("traceframe %d has no static trace data", tfnum
);
5316 /* Callback for traceframe_walk_blocks. Builds a traceframe-info
5317 object. DATA is pointer to a struct buffer holding the
5318 traceframe-info object being built. */
5321 build_traceframe_info_xml (char blocktype
, unsigned char *dataptr
, void *data
)
5323 struct buffer
*buffer
= data
;
5329 unsigned short mlen
;
5332 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5333 dataptr
+= sizeof (maddr
);
5334 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5335 dataptr
+= sizeof (mlen
);
5336 buffer_xml_printf (buffer
,
5337 "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5338 paddress (maddr
), phex_nz (mlen
, sizeof (mlen
)));
5348 warning ("Unhandled trace block type (%d) '%c ' "
5349 "while building trace frame info.",
5350 blocktype
, blocktype
);
5357 /* Build a traceframe-info object for traceframe number TFNUM into
5361 traceframe_read_info (int tfnum
, struct buffer
*buffer
)
5363 struct traceframe
*tframe
;
5365 trace_debug ("traceframe_read_info");
5367 tframe
= find_traceframe (tfnum
);
5371 trace_debug ("traceframe %d not found", tfnum
);
5375 buffer_grow_str (buffer
, "<traceframe-info>\n");
5376 traceframe_walk_blocks (tframe
->data
, tframe
->data_size
,
5377 tfnum
, build_traceframe_info_xml
, buffer
);
5378 buffer_grow_str0 (buffer
, "</traceframe-info>\n");
5382 /* Return the first fast tracepoint whose jump pad contains PC. */
5384 static struct tracepoint
*
5385 fast_tracepoint_from_jump_pad_address (CORE_ADDR pc
)
5387 struct tracepoint
*tpoint
;
5389 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5390 if (tpoint
->type
== fast_tracepoint
)
5391 if (tpoint
->jump_pad
<= pc
&& pc
< tpoint
->jump_pad_end
)
5397 /* Return the first fast tracepoint whose trampoline contains PC. */
5399 static struct tracepoint
*
5400 fast_tracepoint_from_trampoline_address (CORE_ADDR pc
)
5402 struct tracepoint
*tpoint
;
5404 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5406 if (tpoint
->type
== fast_tracepoint
5407 && tpoint
->trampoline
<= pc
&& pc
< tpoint
->trampoline_end
)
5414 /* Return GDBserver's tracepoint that matches the IP Agent's
5415 tracepoint object that lives at IPA_TPOINT_OBJ in the IP Agent's
5418 static struct tracepoint
*
5419 fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR ipa_tpoint_obj
)
5421 struct tracepoint
*tpoint
;
5423 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5424 if (tpoint
->type
== fast_tracepoint
)
5425 if (tpoint
->obj_addr_on_target
== ipa_tpoint_obj
)
5433 /* The type of the object that is used to synchronize fast tracepoint
5436 typedef struct collecting_t
5438 /* The fast tracepoint number currently collecting. */
5441 /* A number that GDBserver can use to identify the thread that is
5442 presently holding the collect lock. This need not (and usually
5443 is not) the thread id, as getting the current thread ID usually
5444 requires a system call, which we want to avoid like the plague.
5445 Usually this is thread's TCB, found in the TLS (pseudo-)
5446 register, which is readable with a single insn on several
5448 uintptr_t thread_area
;
5451 #ifndef IN_PROCESS_AGENT
5454 force_unlock_trace_buffer (void)
5456 write_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
, 0);
5459 /* Check if the thread identified by THREAD_AREA which is stopped at
5460 STOP_PC, is presently locking the fast tracepoint collection, and
5461 if so, gather some status of said collection. Returns 0 if the
5462 thread isn't collecting or in the jump pad at all. 1, if in the
5463 jump pad (or within gdb_collect) and hasn't executed the adjusted
5464 original insn yet (can set a breakpoint there and run to it). 2,
5465 if presently executing the adjusted original insn --- in which
5466 case, if we want to move the thread out of the jump pad, we need to
5467 single-step it until this function returns 0. */
5470 fast_tracepoint_collecting (CORE_ADDR thread_area
,
5472 struct fast_tpoint_collect_status
*status
)
5474 CORE_ADDR ipa_collecting
;
5475 CORE_ADDR ipa_gdb_jump_pad_buffer
, ipa_gdb_jump_pad_buffer_end
;
5476 CORE_ADDR ipa_gdb_trampoline_buffer
;
5477 CORE_ADDR ipa_gdb_trampoline_buffer_end
;
5478 struct tracepoint
*tpoint
;
5479 int needs_breakpoint
;
5481 /* The thread THREAD_AREA is either:
5483 0. not collecting at all, not within the jump pad, or within
5484 gdb_collect or one of its callees.
5486 1. in the jump pad and haven't reached gdb_collect
5488 2. within gdb_collect (out of the jump pad) (collect is set)
5490 3. we're in the jump pad, after gdb_collect having returned,
5491 possibly executing the adjusted insns.
5493 For cases 1 and 3, `collecting' may or not be set. The jump pad
5494 doesn't have any complicated jump logic, so we can tell if the
5495 thread is executing the adjust original insn or not by just
5496 matching STOP_PC with known jump pad addresses. If we it isn't
5497 yet executing the original insn, set a breakpoint there, and let
5498 the thread run to it, so to quickly step over a possible (many
5499 insns) gdb_collect call. Otherwise, or when the breakpoint is
5500 hit, only a few (small number of) insns are left to be executed
5501 in the jump pad. Single-step the thread until it leaves the
5506 needs_breakpoint
= 0;
5507 trace_debug ("fast_tracepoint_collecting");
5509 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
5510 &ipa_gdb_jump_pad_buffer
))
5511 fatal ("error extracting `gdb_jump_pad_buffer'");
5512 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer_end
,
5513 &ipa_gdb_jump_pad_buffer_end
))
5514 fatal ("error extracting `gdb_jump_pad_buffer_end'");
5516 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
5517 &ipa_gdb_trampoline_buffer
))
5518 fatal ("error extracting `gdb_trampoline_buffer'");
5519 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
5520 &ipa_gdb_trampoline_buffer_end
))
5521 fatal ("error extracting `gdb_trampoline_buffer_end'");
5523 if (ipa_gdb_jump_pad_buffer
<= stop_pc
5524 && stop_pc
< ipa_gdb_jump_pad_buffer_end
)
5526 /* We can tell which tracepoint(s) the thread is collecting by
5527 matching the jump pad address back to the tracepoint. */
5528 tpoint
= fast_tracepoint_from_jump_pad_address (stop_pc
);
5531 warning ("in jump pad, but no matching tpoint?");
5536 trace_debug ("in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5538 tpoint
->number
, paddress (tpoint
->address
),
5539 paddress (tpoint
->jump_pad
),
5540 paddress (tpoint
->jump_pad_end
),
5541 paddress (tpoint
->adjusted_insn_addr
),
5542 paddress (tpoint
->adjusted_insn_addr_end
));
5545 /* Definitely in the jump pad. May or may not need
5546 fast-exit-jump-pad breakpoint. */
5547 if (tpoint
->jump_pad
<= stop_pc
5548 && stop_pc
< tpoint
->adjusted_insn_addr
)
5549 needs_breakpoint
= 1;
5551 else if (ipa_gdb_trampoline_buffer
<= stop_pc
5552 && stop_pc
< ipa_gdb_trampoline_buffer_end
)
5554 /* We can tell which tracepoint(s) the thread is collecting by
5555 matching the trampoline address back to the tracepoint. */
5556 tpoint
= fast_tracepoint_from_trampoline_address (stop_pc
);
5559 warning ("in trampoline, but no matching tpoint?");
5564 trace_debug ("in trampoline of tpoint (%d, %s); trampoline(%s, %s)",
5565 tpoint
->number
, paddress (tpoint
->address
),
5566 paddress (tpoint
->trampoline
),
5567 paddress (tpoint
->trampoline_end
));
5570 /* Have not reached jump pad yet, but treat the trampoline as a
5571 part of the jump pad that is before the adjusted original
5573 needs_breakpoint
= 1;
5577 collecting_t ipa_collecting_obj
;
5579 /* If `collecting' is set/locked, then the THREAD_AREA thread
5580 may or not be the one holding the lock. We have to read the
5581 lock to find out. */
5583 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
,
5586 trace_debug ("fast_tracepoint_collecting:"
5587 " failed reading 'collecting' in the inferior");
5591 if (!ipa_collecting
)
5593 trace_debug ("fast_tracepoint_collecting: not collecting"
5594 " (and nobody is).");
5598 /* Some thread is collecting. Check which. */
5599 if (read_inferior_memory (ipa_collecting
,
5600 (unsigned char *) &ipa_collecting_obj
,
5601 sizeof (ipa_collecting_obj
)) != 0)
5604 if (ipa_collecting_obj
.thread_area
!= thread_area
)
5606 trace_debug ("fast_tracepoint_collecting: not collecting "
5607 "(another thread is)");
5612 = fast_tracepoint_from_ipa_tpoint_address (ipa_collecting_obj
.tpoint
);
5615 warning ("fast_tracepoint_collecting: collecting, "
5616 "but tpoint %s not found?",
5617 paddress ((CORE_ADDR
) ipa_collecting_obj
.tpoint
));
5621 /* The thread is within `gdb_collect', skip over the rest of
5622 fast tracepoint collection quickly using a breakpoint. */
5623 needs_breakpoint
= 1;
5626 /* The caller wants a bit of status detail. */
5629 status
->tpoint_num
= tpoint
->number
;
5630 status
->tpoint_addr
= tpoint
->address
;
5631 status
->adjusted_insn_addr
= tpoint
->adjusted_insn_addr
;
5632 status
->adjusted_insn_addr_end
= tpoint
->adjusted_insn_addr_end
;
5635 if (needs_breakpoint
)
5637 /* Hasn't executed the original instruction yet. Set breakpoint
5638 there, and wait till it's hit, then single-step until exiting
5642 fast_tracepoint_collecting, returning continue-until-break at %s",
5643 paddress (tpoint
->adjusted_insn_addr
));
5645 return 1; /* continue */
5649 /* Just single-step until exiting the jump pad. */
5651 trace_debug ("fast_tracepoint_collecting, returning "
5652 "need-single-step (%s-%s)",
5653 paddress (tpoint
->adjusted_insn_addr
),
5654 paddress (tpoint
->adjusted_insn_addr_end
));
5656 return 2; /* single-step */
5662 #ifdef IN_PROCESS_AGENT
5664 /* The global fast tracepoint collect lock. Points to a collecting_t
5665 object built on the stack by the jump pad, if presently locked;
5666 NULL if it isn't locked. Note that this lock *must* be set while
5667 executing any *function other than the jump pad. See
5668 fast_tracepoint_collecting. */
5669 static collecting_t
* ATTR_USED collecting
;
5671 /* This routine, called from the jump pad (in asm) is designed to be
5672 called from the jump pads of fast tracepoints, thus it is on the
5675 IP_AGENT_EXPORT
void ATTR_USED
5676 gdb_collect (struct tracepoint
*tpoint
, unsigned char *regs
)
5678 struct fast_tracepoint_ctx ctx
;
5680 /* Don't do anything until the trace run is completely set up. */
5684 ctx
.base
.type
= fast_tracepoint
;
5686 ctx
.regcache_initted
= 0;
5687 /* Wrap the regblock in a register cache (in the stack, we don't
5688 want to malloc here). */
5689 ctx
.regspace
= alloca (register_cache_size ());
5690 if (ctx
.regspace
== NULL
)
5692 trace_debug ("Trace buffer block allocation failed, skipping");
5696 for (ctx
.tpoint
= tpoint
;
5697 ctx
.tpoint
!= NULL
&& ctx
.tpoint
->address
== tpoint
->address
;
5698 ctx
.tpoint
= ctx
.tpoint
->next
)
5700 if (!ctx
.tpoint
->enabled
)
5703 /* Multiple tracepoints of different types, such as fast tracepoint and
5704 static tracepoint, can be set at the same address. */
5705 if (ctx
.tpoint
->type
!= tpoint
->type
)
5708 /* Test the condition if present, and collect if true. */
5709 if (ctx
.tpoint
->cond
== NULL
5710 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5713 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5714 ctx
.tpoint
->address
, ctx
.tpoint
);
5716 /* Note that this will cause original insns to be written back
5717 to where we jumped from, but that's OK because we're jumping
5718 back to the next whole instruction. This will go badly if
5719 instruction restoration is not atomic though. */
5720 if (stopping_tracepoint
5721 || trace_buffer_is_full
5722 || expr_eval_result
!= expr_eval_no_error
)
5730 /* If there was a condition and it evaluated to false, the only
5731 way we would stop tracing is if there was an error during
5732 condition expression evaluation. */
5733 if (expr_eval_result
!= expr_eval_no_error
)
5744 #ifndef IN_PROCESS_AGENT
5747 get_raw_reg_func_addr (void)
5749 return ipa_sym_addrs
.addr_get_raw_reg
;
5753 get_get_tsv_func_addr (void)
5755 return ipa_sym_addrs
.addr_get_trace_state_variable_value
;
5759 get_set_tsv_func_addr (void)
5761 return ipa_sym_addrs
.addr_set_trace_state_variable_value
;
5765 compile_tracepoint_condition (struct tracepoint
*tpoint
,
5766 CORE_ADDR
*jump_entry
)
5768 CORE_ADDR entry_point
= *jump_entry
;
5769 enum eval_result_type err
;
5771 trace_debug ("Starting condition compilation for tracepoint %d\n",
5774 /* Initialize the global pointer to the code being built. */
5775 current_insn_ptr
= *jump_entry
;
5779 err
= compile_bytecodes (tpoint
->cond
);
5781 if (err
== expr_eval_no_error
)
5785 /* Record the beginning of the compiled code. */
5786 tpoint
->compiled_cond
= entry_point
;
5788 trace_debug ("Condition compilation for tracepoint %d complete\n",
5793 /* Leave the unfinished code in situ, but don't point to it. */
5795 tpoint
->compiled_cond
= 0;
5797 trace_debug ("Condition compilation for tracepoint %d failed, "
5799 tpoint
->number
, err
);
5802 /* Update the code pointer passed in. Note that we do this even if
5803 the compile fails, so that we can look at the partial results
5804 instead of letting them be overwritten. */
5805 *jump_entry
= current_insn_ptr
;
5807 /* Leave a gap, to aid dump decipherment. */
5811 /* We'll need to adjust these when we consider bi-arch setups, and big
5815 write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
)
5817 return write_inferior_memory (where
,
5818 (unsigned char *) &ptr
, sizeof (void *));
5821 /* The base pointer of the IPA's heap. This is the only memory the
5822 IPA is allowed to use. The IPA should _not_ call the inferior's
5823 `malloc' during operation. That'd be slow, and, most importantly,
5824 it may not be safe. We may be collecting a tracepoint in a signal
5825 handler, for example. */
5826 static CORE_ADDR target_tp_heap
;
5828 /* Allocate at least SIZE bytes of memory from the IPA heap, aligned
5832 target_malloc (ULONGEST size
)
5836 if (target_tp_heap
== 0)
5838 /* We have the pointer *address*, need what it points to. */
5839 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_tp_heap_buffer
,
5841 fatal ("could get target heap head pointer");
5844 ptr
= target_tp_heap
;
5845 target_tp_heap
+= size
;
5847 /* Pad to 8-byte alignment. */
5848 target_tp_heap
= ((target_tp_heap
+ 7) & ~0x7);
5854 download_agent_expr (struct agent_expr
*expr
)
5856 CORE_ADDR expr_addr
;
5857 CORE_ADDR expr_bytes
;
5859 expr_addr
= target_malloc (sizeof (*expr
));
5860 write_inferior_memory (expr_addr
, (unsigned char *) expr
, sizeof (*expr
));
5862 expr_bytes
= target_malloc (expr
->length
);
5863 write_inferior_data_ptr (expr_addr
+ offsetof (struct agent_expr
, bytes
),
5865 write_inferior_memory (expr_bytes
, expr
->bytes
, expr
->length
);
5870 /* Align V up to N bits. */
5871 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
5873 /* Sync tracepoint with IPA, but leave maintenance of linked list to caller. */
5876 download_tracepoint_1 (struct tracepoint
*tpoint
)
5878 struct tracepoint target_tracepoint
;
5879 CORE_ADDR tpptr
= 0;
5881 gdb_assert (tpoint
->type
== fast_tracepoint
5882 || tpoint
->type
== static_tracepoint
);
5884 if (tpoint
->cond
!= NULL
&& target_emit_ops () != NULL
)
5886 CORE_ADDR jentry
, jump_entry
;
5888 jentry
= jump_entry
= get_jump_space_head ();
5890 if (tpoint
->cond
!= NULL
)
5892 /* Pad to 8-byte alignment. (needed?) */
5893 /* Actually this should be left for the target to
5895 jentry
= UALIGN (jentry
, 8);
5897 compile_tracepoint_condition (tpoint
, &jentry
);
5900 /* Pad to 8-byte alignment. */
5901 jentry
= UALIGN (jentry
, 8);
5902 claim_jump_space (jentry
- jump_entry
);
5905 target_tracepoint
= *tpoint
;
5907 tpptr
= target_malloc (sizeof (*tpoint
));
5908 tpoint
->obj_addr_on_target
= tpptr
;
5910 /* Write the whole object. We'll fix up its pointers in a bit.
5911 Assume no next for now. This is fixed up above on the next
5912 iteration, if there's any. */
5913 target_tracepoint
.next
= NULL
;
5914 /* Need to clear this here too, since we're downloading the
5915 tracepoints before clearing our own copy. */
5916 target_tracepoint
.hit_count
= 0;
5918 write_inferior_memory (tpptr
, (unsigned char *) &target_tracepoint
,
5919 sizeof (target_tracepoint
));
5922 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
5924 download_agent_expr (tpoint
->cond
));
5926 if (tpoint
->numactions
)
5929 CORE_ADDR actions_array
;
5931 /* The pointers array. */
5933 = target_malloc (sizeof (*tpoint
->actions
) * tpoint
->numactions
);
5934 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
5938 /* Now for each pointer, download the action. */
5939 for (i
= 0; i
< tpoint
->numactions
; i
++)
5941 struct tracepoint_action
*action
= tpoint
->actions
[i
];
5942 CORE_ADDR ipa_action
= action
->ops
->download (action
);
5944 if (ipa_action
!= 0)
5945 write_inferior_data_ptr
5946 (actions_array
+ i
* sizeof (sizeof (*tpoint
->actions
)),
5952 #define IPA_PROTO_FAST_TRACE_FLAG 0
5953 #define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
5954 #define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
5955 #define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
5956 #define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
5958 /* Send a command to agent to download and install tracepoint TPOINT. */
5961 tracepoint_send_agent (struct tracepoint
*tpoint
)
5963 char buf
[IPA_CMD_BUF_SIZE
];
5968 strcpy (p
, "FastTrace:");
5971 COPY_FIELD_TO_BUF (p
, tpoint
, number
);
5972 COPY_FIELD_TO_BUF (p
, tpoint
, address
);
5973 COPY_FIELD_TO_BUF (p
, tpoint
, type
);
5974 COPY_FIELD_TO_BUF (p
, tpoint
, enabled
);
5975 COPY_FIELD_TO_BUF (p
, tpoint
, step_count
);
5976 COPY_FIELD_TO_BUF (p
, tpoint
, pass_count
);
5977 COPY_FIELD_TO_BUF (p
, tpoint
, numactions
);
5978 COPY_FIELD_TO_BUF (p
, tpoint
, hit_count
);
5979 COPY_FIELD_TO_BUF (p
, tpoint
, traceframe_usage
);
5980 COPY_FIELD_TO_BUF (p
, tpoint
, compiled_cond
);
5981 COPY_FIELD_TO_BUF (p
, tpoint
, orig_size
);
5984 p
= agent_expr_send (p
, tpoint
->cond
);
5986 /* tracepoint_action */
5987 for (i
= 0; i
< tpoint
->numactions
; i
++)
5989 struct tracepoint_action
*action
= tpoint
->actions
[i
];
5991 p
[0] = action
->type
;
5992 p
= action
->ops
->send (&p
[1], action
);
5995 get_jump_space_head ();
5996 /* Copy the value of GDB_JUMP_PAD_HEAD to command buffer, so that
5997 agent can use jump pad from it. */
5998 if (tpoint
->type
== fast_tracepoint
)
6000 memcpy (p
, &gdb_jump_pad_head
, 8);
6004 ret
= run_inferior_command (buf
, (int) (ptrdiff_t) (p
- buf
));
6008 if (strncmp (buf
, "OK", 2) != 0)
6011 /* The value of tracepoint's target address is stored in BUF. */
6012 memcpy (&tpoint
->obj_addr_on_target
,
6013 &buf
[IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET
], 8);
6015 if (tpoint
->type
== fast_tracepoint
)
6018 = (unsigned char *) &buf
[IPA_PROTO_FAST_TRACE_FJUMP_INSN
];
6021 trace_debug ("agent: read from cmd_buf 0x%x 0x%x\n",
6022 (unsigned int) tpoint
->obj_addr_on_target
,
6023 (unsigned int) gdb_jump_pad_head
);
6025 memcpy (&gdb_jump_pad_head
, &buf
[IPA_PROTO_FAST_TRACE_JUMP_PAD
], 8);
6027 /* This has been done in agent. We should also set up record for it. */
6028 memcpy (&fjump_size
, &buf
[IPA_PROTO_FAST_TRACE_FJUMP_SIZE
], 4);
6031 = set_fast_tracepoint_jump (tpoint
->address
, insn
, fjump_size
);
6038 download_tracepoint (struct tracepoint
*tpoint
)
6040 struct tracepoint
*tp
, *tp_prev
;
6042 if (tpoint
->type
!= fast_tracepoint
6043 && tpoint
->type
!= static_tracepoint
)
6046 download_tracepoint_1 (tpoint
);
6048 /* Find the previous entry of TPOINT, which is fast tracepoint or
6049 static tracepoint. */
6051 for (tp
= tracepoints
; tp
!= tpoint
; tp
= tp
->next
)
6053 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
6059 CORE_ADDR tp_prev_target_next_addr
;
6061 /* Insert TPOINT after TP_PREV in IPA. */
6062 if (read_inferior_data_pointer (tp_prev
->obj_addr_on_target
6063 + offsetof (struct tracepoint
, next
),
6064 &tp_prev_target_next_addr
))
6065 fatal ("error reading `tp_prev->next'");
6067 /* tpoint->next = tp_prev->next */
6068 write_inferior_data_ptr (tpoint
->obj_addr_on_target
6069 + offsetof (struct tracepoint
, next
),
6070 tp_prev_target_next_addr
);
6071 /* tp_prev->next = tpoint */
6072 write_inferior_data_ptr (tp_prev
->obj_addr_on_target
6073 + offsetof (struct tracepoint
, next
),
6074 tpoint
->obj_addr_on_target
);
6077 /* First object in list, set the head pointer in the
6079 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
,
6080 tpoint
->obj_addr_on_target
);
6085 download_trace_state_variables (void)
6087 CORE_ADDR ptr
= 0, prev_ptr
= 0;
6088 struct trace_state_variable
*tsv
;
6090 /* Start out empty. */
6091 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
, 0);
6093 for (tsv
= trace_state_variables
; tsv
!= NULL
; tsv
= tsv
->next
)
6095 struct trace_state_variable target_tsv
;
6097 /* TSV's with a getter have been initialized equally in both the
6098 inferior and GDBserver. Skip them. */
6099 if (tsv
->getter
!= NULL
)
6105 ptr
= target_malloc (sizeof (*tsv
));
6107 if (tsv
== trace_state_variables
)
6109 /* First object in list, set the head pointer in the
6112 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
,
6117 write_inferior_data_ptr (prev_ptr
6118 + offsetof (struct trace_state_variable
,
6123 /* Write the whole object. We'll fix up its pointers in a bit.
6124 Assume no next, fixup when needed. */
6125 target_tsv
.next
= NULL
;
6127 write_inferior_memory (ptr
, (unsigned char *) &target_tsv
,
6128 sizeof (target_tsv
));
6130 if (tsv
->name
!= NULL
)
6132 size_t size
= strlen (tsv
->name
) + 1;
6133 CORE_ADDR name_addr
= target_malloc (size
);
6134 write_inferior_memory (name_addr
,
6135 (unsigned char *) tsv
->name
, size
);
6136 write_inferior_data_ptr (ptr
6137 + offsetof (struct trace_state_variable
,
6142 if (tsv
->getter
!= NULL
)
6144 fatal ("what to do with these?");
6150 /* Fixup the next pointer in the last item in the list. */
6151 write_inferior_data_ptr (prev_ptr
6152 + offsetof (struct trace_state_variable
,
6157 /* Upload complete trace frames out of the IP Agent's trace buffer
6158 into GDBserver's trace buffer. This always uploads either all or
6159 no trace frames. This is the counter part of
6160 `trace_alloc_trace_buffer'. See its description of the atomic
6161 synching mechanism. */
6164 upload_fast_traceframes (void)
6166 unsigned int ipa_traceframe_read_count
, ipa_traceframe_write_count
;
6167 unsigned int ipa_traceframe_read_count_racy
, ipa_traceframe_write_count_racy
;
6169 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
6170 unsigned int curr_tbctrl_idx
;
6171 unsigned int ipa_trace_buffer_ctrl_curr
;
6172 unsigned int ipa_trace_buffer_ctrl_curr_old
;
6173 CORE_ADDR ipa_trace_buffer_ctrl_addr
;
6174 struct breakpoint
*about_to_request_buffer_space_bkpt
;
6175 CORE_ADDR ipa_trace_buffer_lo
;
6176 CORE_ADDR ipa_trace_buffer_hi
;
6178 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6179 &ipa_traceframe_read_count_racy
))
6181 /* This will happen in most targets if the current thread is
6186 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6187 &ipa_traceframe_write_count_racy
))
6190 trace_debug ("ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6191 ipa_traceframe_write_count_racy
6192 - ipa_traceframe_read_count_racy
,
6193 ipa_traceframe_write_count_racy
,
6194 ipa_traceframe_read_count_racy
);
6196 if (ipa_traceframe_write_count_racy
== ipa_traceframe_read_count_racy
)
6199 about_to_request_buffer_space_bkpt
6200 = set_breakpoint_at (ipa_sym_addrs
.addr_about_to_request_buffer_space
,
6203 if (read_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6204 &ipa_trace_buffer_ctrl_curr
))
6207 ipa_trace_buffer_ctrl_curr_old
= ipa_trace_buffer_ctrl_curr
;
6209 curr_tbctrl_idx
= ipa_trace_buffer_ctrl_curr
& ~GDBSERVER_FLUSH_COUNT_MASK
;
6212 unsigned int prev
, counter
;
6214 /* Update the token, with new counters, and the GDBserver stamp
6215 bit. Alway reuse the current TBC index. */
6216 prev
= ipa_trace_buffer_ctrl_curr
& GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6217 counter
= (prev
+ 0x100) & GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6219 ipa_trace_buffer_ctrl_curr
= (GDBSERVER_UPDATED_FLUSH_COUNT_BIT
6225 if (write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6226 ipa_trace_buffer_ctrl_curr
))
6229 trace_debug ("Lib: Committed %08x -> %08x",
6230 ipa_trace_buffer_ctrl_curr_old
,
6231 ipa_trace_buffer_ctrl_curr
);
6233 /* Re-read these, now that we've installed the
6234 `about_to_request_buffer_space' breakpoint/lock. A thread could
6235 have finished a traceframe between the last read of these
6236 counters and setting the breakpoint above. If we start
6237 uploading, we never want to leave this function with
6238 traceframe_read_count != 0, otherwise, GDBserver could end up
6239 incrementing the counter tokens more than once (due to event loop
6240 nesting), which would break the IP agent's "effective" detection
6241 (see trace_alloc_trace_buffer). */
6242 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6243 &ipa_traceframe_read_count
))
6245 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6246 &ipa_traceframe_write_count
))
6251 trace_debug ("ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6252 ipa_traceframe_write_count
- ipa_traceframe_read_count
,
6253 ipa_traceframe_write_count
, ipa_traceframe_read_count
);
6255 if (ipa_traceframe_write_count
!= ipa_traceframe_write_count_racy
6256 || ipa_traceframe_read_count
!= ipa_traceframe_read_count_racy
)
6257 trace_debug ("note that ipa_traceframe_count's parts changed");
6260 /* Get the address of the current TBC object (the IP agent has an
6261 array of 3 such objects). The index is stored in the TBC
6263 ipa_trace_buffer_ctrl_addr
= ipa_sym_addrs
.addr_trace_buffer_ctrl
;
6264 ipa_trace_buffer_ctrl_addr
6265 += sizeof (struct ipa_trace_buffer_control
) * curr_tbctrl_idx
;
6267 if (read_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6268 (unsigned char *) &ipa_trace_buffer_ctrl
,
6269 sizeof (struct ipa_trace_buffer_control
)))
6272 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
6273 &ipa_trace_buffer_lo
))
6275 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
6276 &ipa_trace_buffer_hi
))
6279 /* Offsets are easier to grok for debugging than raw addresses,
6280 especially for the small trace buffer sizes that are useful for
6282 trace_debug ("Lib: Trace buffer [%d] start=%d free=%d "
6283 "endfree=%d wrap=%d hi=%d",
6285 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6286 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6287 (int) (ipa_trace_buffer_ctrl
.end_free
- ipa_trace_buffer_lo
),
6288 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6289 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6291 /* Note that the IPA's buffer is always circular. */
6293 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6295 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6296 ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6298 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6299 (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6300 - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6301 ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6304 tf
= IPA_FIRST_TRACEFRAME ();
6306 while (ipa_traceframe_write_count
- ipa_traceframe_read_count
)
6308 struct tracepoint
*tpoint
;
6309 struct traceframe
*tframe
;
6310 unsigned char *block
;
6311 struct traceframe ipa_tframe
;
6313 if (read_inferior_memory (tf
, (unsigned char *) &ipa_tframe
,
6314 offsetof (struct traceframe
, data
)))
6315 error ("Uploading: couldn't read traceframe at %s\n", paddress (tf
));
6317 if (ipa_tframe
.tpnum
== 0)
6318 fatal ("Uploading: No (more) fast traceframes, but "
6319 "ipa_traceframe_count == %u??\n",
6320 ipa_traceframe_write_count
- ipa_traceframe_read_count
);
6322 /* Note that this will be incorrect for multi-location
6324 tpoint
= find_next_tracepoint_by_number (NULL
, ipa_tframe
.tpnum
);
6326 tframe
= add_traceframe (tpoint
);
6329 trace_buffer_is_full
= 1;
6330 trace_debug ("Uploading: trace buffer is full");
6334 /* Copy the whole set of blocks in one go for now. FIXME:
6335 split this in smaller blocks. */
6336 block
= add_traceframe_block (tframe
, tpoint
,
6337 ipa_tframe
.data_size
);
6340 if (read_inferior_memory (tf
6341 + offsetof (struct traceframe
, data
),
6342 block
, ipa_tframe
.data_size
))
6343 error ("Uploading: Couldn't read traceframe data at %s\n",
6344 paddress (tf
+ offsetof (struct traceframe
, data
)));
6347 trace_debug ("Uploading: traceframe didn't fit");
6348 finish_traceframe (tframe
);
6351 tf
= IPA_NEXT_TRACEFRAME (tf
, &ipa_tframe
);
6353 /* If we freed the traceframe that wrapped around, go back
6354 to the non-wrap case. */
6355 if (tf
< ipa_trace_buffer_ctrl
.start
)
6357 trace_debug ("Lib: Discarding past the wraparound");
6358 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6360 ipa_trace_buffer_ctrl
.start
= tf
;
6361 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_ctrl
.start
;
6362 ++ipa_traceframe_read_count
;
6364 if (ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.free
6365 && ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.end_free
)
6367 trace_debug ("Lib: buffer is fully empty. "
6368 "Trace buffer [%d] start=%d free=%d endfree=%d",
6370 (int) (ipa_trace_buffer_ctrl
.start
6371 - ipa_trace_buffer_lo
),
6372 (int) (ipa_trace_buffer_ctrl
.free
6373 - ipa_trace_buffer_lo
),
6374 (int) (ipa_trace_buffer_ctrl
.end_free
6375 - ipa_trace_buffer_lo
));
6377 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
6378 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
6379 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
6380 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6383 trace_debug ("Uploaded a traceframe\n"
6384 "Lib: Trace buffer [%d] start=%d free=%d "
6385 "endfree=%d wrap=%d hi=%d",
6387 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6388 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6389 (int) (ipa_trace_buffer_ctrl
.end_free
6390 - ipa_trace_buffer_lo
),
6391 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6392 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6395 if (write_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6396 (unsigned char *) &ipa_trace_buffer_ctrl
,
6397 sizeof (struct ipa_trace_buffer_control
)))
6400 write_inferior_integer (ipa_sym_addrs
.addr_traceframe_read_count
,
6401 ipa_traceframe_read_count
);
6403 trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx
);
6406 cancel_breakpoints ();
6408 delete_breakpoint (about_to_request_buffer_space_bkpt
);
6409 about_to_request_buffer_space_bkpt
= NULL
;
6413 if (trace_buffer_is_full
)
6418 #ifdef IN_PROCESS_AGENT
6420 IP_AGENT_EXPORT
int ust_loaded
;
6421 IP_AGENT_EXPORT
char cmd_buf
[IPA_CMD_BUF_SIZE
];
6425 /* Static tracepoints. */
6427 /* UST puts a "struct tracepoint" in the global namespace, which
6428 conflicts with our tracepoint. Arguably, being a library, it
6429 shouldn't take ownership of such a generic name. We work around it
6431 #define tracepoint ust_tracepoint
6432 #include <ust/ust.h>
6435 extern int serialize_to_text (char *outbuf
, int bufsize
,
6436 const char *fmt
, va_list ap
);
6438 #define GDB_PROBE_NAME "gdb"
6440 /* We dynamically search for the UST symbols instead of linking them
6441 in. This lets the user decide if the application uses static
6442 tracepoints, instead of always pulling libust.so in. This vector
6443 holds pointers to all functions we care about. */
6447 int (*serialize_to_text
) (char *outbuf
, int bufsize
,
6448 const char *fmt
, va_list ap
);
6450 int (*ltt_probe_register
) (struct ltt_available_probe
*pdata
);
6451 int (*ltt_probe_unregister
) (struct ltt_available_probe
*pdata
);
6453 int (*ltt_marker_connect
) (const char *channel
, const char *mname
,
6455 int (*ltt_marker_disconnect
) (const char *channel
, const char *mname
,
6458 void (*marker_iter_start
) (struct marker_iter
*iter
);
6459 void (*marker_iter_next
) (struct marker_iter
*iter
);
6460 void (*marker_iter_stop
) (struct marker_iter
*iter
);
6461 void (*marker_iter_reset
) (struct marker_iter
*iter
);
6466 /* Cast through typeof to catch incompatible API changes. Since UST
6467 only builds with gcc, we can freely use gcc extensions here
6469 #define GET_UST_SYM(SYM) \
6472 if (ust_ops.SYM == NULL) \
6473 ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6474 if (ust_ops.SYM == NULL) \
6478 #define USTF(SYM) ust_ops.SYM
6480 /* Get pointers to all libust.so functions we care about. */
6485 GET_UST_SYM (serialize_to_text
);
6487 GET_UST_SYM (ltt_probe_register
);
6488 GET_UST_SYM (ltt_probe_unregister
);
6489 GET_UST_SYM (ltt_marker_connect
);
6490 GET_UST_SYM (ltt_marker_disconnect
);
6492 GET_UST_SYM (marker_iter_start
);
6493 GET_UST_SYM (marker_iter_next
);
6494 GET_UST_SYM (marker_iter_stop
);
6495 GET_UST_SYM (marker_iter_reset
);
6501 /* Given an UST marker, return the matching gdb static tracepoint.
6502 The match is done by address. */
6504 static struct tracepoint
*
6505 ust_marker_to_static_tracepoint (const struct marker
*mdata
)
6507 struct tracepoint
*tpoint
;
6509 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
6511 if (tpoint
->type
!= static_tracepoint
)
6514 if (tpoint
->address
== (uintptr_t) mdata
->location
)
6521 /* The probe function we install on lttng/ust markers. Whenever a
6522 probed ust marker is hit, this function is called. This is similar
6523 to gdb_collect, only for static tracepoints, instead of fast
6527 gdb_probe (const struct marker
*mdata
, void *probe_private
,
6528 struct registers
*regs
, void *call_private
,
6529 const char *fmt
, va_list *args
)
6531 struct tracepoint
*tpoint
;
6532 struct static_tracepoint_ctx ctx
;
6534 /* Don't do anything until the trace run is completely set up. */
6537 trace_debug ("gdb_probe: not tracing\n");
6541 ctx
.base
.type
= static_tracepoint
;
6542 ctx
.regcache_initted
= 0;
6547 /* Wrap the regblock in a register cache (in the stack, we don't
6548 want to malloc here). */
6549 ctx
.regspace
= alloca (register_cache_size ());
6550 if (ctx
.regspace
== NULL
)
6552 trace_debug ("Trace buffer block allocation failed, skipping");
6556 tpoint
= ust_marker_to_static_tracepoint (mdata
);
6559 trace_debug ("gdb_probe: marker not known: "
6560 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6561 mdata
->location
, mdata
->channel
,
6562 mdata
->name
, mdata
->format
);
6566 if (!tpoint
->enabled
)
6568 trace_debug ("gdb_probe: tracepoint disabled");
6572 ctx
.tpoint
= tpoint
;
6574 trace_debug ("gdb_probe: collecting marker: "
6575 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6576 mdata
->location
, mdata
->channel
,
6577 mdata
->name
, mdata
->format
);
6579 /* Test the condition if present, and collect if true. */
6580 if (tpoint
->cond
== NULL
6581 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6584 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6585 tpoint
->address
, tpoint
);
6587 if (stopping_tracepoint
6588 || trace_buffer_is_full
6589 || expr_eval_result
!= expr_eval_no_error
)
6594 /* If there was a condition and it evaluated to false, the only
6595 way we would stop tracing is if there was an error during
6596 condition expression evaluation. */
6597 if (expr_eval_result
!= expr_eval_no_error
)
6602 /* Called if the gdb static tracepoint requested collecting "$_sdata",
6603 static tracepoint string data. This is a string passed to the
6604 tracing library by the user, at the time of the tracepoint marker
6605 call. E.g., in the UST marker call:
6607 trace_mark (ust, bar33, "str %s", "FOOBAZ");
6609 the collected data is "str FOOBAZ".
6613 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
6614 struct traceframe
*tframe
)
6616 struct static_tracepoint_ctx
*umd
= (struct static_tracepoint_ctx
*) ctx
;
6617 unsigned char *bufspace
;
6620 unsigned short blocklen
;
6624 trace_debug ("Wanted to collect static trace data, "
6625 "but there's no static trace data");
6629 va_copy (copy
, *umd
->args
);
6630 size
= USTF(serialize_to_text
) (NULL
, 0, umd
->fmt
, copy
);
6633 trace_debug ("Want to collect ust data");
6635 /* 'S' + size + string */
6636 bufspace
= add_traceframe_block (tframe
, umd
->tpoint
,
6637 1 + sizeof (blocklen
) + size
+ 1);
6638 if (bufspace
== NULL
)
6640 trace_debug ("Trace buffer block allocation failed, skipping");
6644 /* Identify a static trace data block. */
6647 blocklen
= size
+ 1;
6648 memcpy (bufspace
+ 1, &blocklen
, sizeof (blocklen
));
6650 va_copy (copy
, *umd
->args
);
6651 USTF(serialize_to_text
) ((char *) bufspace
+ 1 + sizeof (blocklen
),
6652 size
+ 1, umd
->fmt
, copy
);
6655 trace_debug ("Storing static tracepoint data in regblock: %s",
6656 bufspace
+ 1 + sizeof (blocklen
));
6659 /* The probe to register with lttng/ust. */
6660 static struct ltt_available_probe gdb_ust_probe
=
6667 #endif /* HAVE_UST */
6668 #endif /* IN_PROCESS_AGENT */
6670 #ifndef IN_PROCESS_AGENT
6672 /* Ask the in-process agent to run a command. Since we don't want to
6673 have to handle the IPA hitting breakpoints while running the
6674 command, we pause all threads, remove all breakpoints, and then set
6675 the helper thread re-running. We communicate with the helper
6676 thread by means of direct memory xfering, and a socket for
6680 run_inferior_command (char *cmd
, int len
)
6683 int pid
= ptid_get_pid (current_ptid
);
6685 trace_debug ("run_inferior_command: running: %s", cmd
);
6688 uninsert_all_breakpoints ();
6690 err
= agent_run_command (pid
, (const char *) cmd
, len
);
6692 reinsert_all_breakpoints ();
6698 #else /* !IN_PROCESS_AGENT */
6700 #include <sys/socket.h>
6703 #ifndef UNIX_PATH_MAX
6704 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6707 /* Where we put the socked used for synchronization. */
6708 #define SOCK_DIR P_tmpdir
6710 /* Thread ID of the helper thread. GDBserver reads this to know which
6711 is the help thread. This is an LWP id on Linux. */
6712 int helper_thread_id
;
6715 init_named_socket (const char *name
)
6718 struct sockaddr_un addr
;
6720 result
= fd
= socket (PF_UNIX
, SOCK_STREAM
, 0);
6723 warning ("socket creation failed: %s", strerror (errno
));
6727 addr
.sun_family
= AF_UNIX
;
6729 strncpy (addr
.sun_path
, name
, UNIX_PATH_MAX
);
6730 addr
.sun_path
[UNIX_PATH_MAX
- 1] = '\0';
6732 result
= access (name
, F_OK
);
6736 result
= unlink (name
);
6739 warning ("unlink failed: %s", strerror (errno
));
6743 warning ("socket %s already exists; overwriting", name
);
6746 result
= bind (fd
, (struct sockaddr
*) &addr
, sizeof (addr
));
6749 warning ("bind failed: %s", strerror (errno
));
6754 result
= listen (fd
, 1);
6757 warning ("listen: %s", strerror (errno
));
6765 static char agent_socket_name
[UNIX_PATH_MAX
];
6768 gdb_agent_socket_init (void)
6772 result
= xsnprintf (agent_socket_name
, UNIX_PATH_MAX
, "%s/gdb_ust%d",
6773 SOCK_DIR
, getpid ());
6774 if (result
>= UNIX_PATH_MAX
)
6776 trace_debug ("string overflow allocating socket name");
6780 fd
= init_named_socket (agent_socket_name
);
6782 warning ("Error initializing named socket (%s) for communication with the "
6783 "ust helper thread. Check that directory exists and that it "
6784 "is writable.", agent_socket_name
);
6791 /* The next marker to be returned on a qTsSTM command. */
6792 static const struct marker
*next_st
;
6794 /* Returns the first known marker. */
6799 struct marker_iter iter
;
6801 USTF(marker_iter_reset
) (&iter
);
6802 USTF(marker_iter_start
) (&iter
);
6807 /* Returns the marker following M. */
6809 const struct marker
*
6810 next_marker (const struct marker
*m
)
6812 struct marker_iter iter
;
6814 USTF(marker_iter_reset
) (&iter
);
6815 USTF(marker_iter_start
) (&iter
);
6817 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
6819 if (iter
.marker
== m
)
6821 USTF(marker_iter_next
) (&iter
);
6829 /* Return an hexstr version of the STR C string, fit for sending to
6833 cstr_to_hexstr (const char *str
)
6835 int len
= strlen (str
);
6836 char *hexstr
= xmalloc (len
* 2 + 1);
6837 convert_int_to_ascii ((gdb_byte
*) str
, hexstr
, len
);
6841 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
6845 response_ust_marker (char *packet
, const struct marker
*st
)
6847 char *strid
, *format
, *tmp
;
6849 next_st
= next_marker (st
);
6851 tmp
= xmalloc (strlen (st
->channel
) + 1 +
6852 strlen (st
->name
) + 1);
6853 sprintf (tmp
, "%s/%s", st
->channel
, st
->name
);
6855 strid
= cstr_to_hexstr (tmp
);
6858 format
= cstr_to_hexstr (st
->format
);
6860 sprintf (packet
, "m%s:%s:%s",
6861 paddress ((uintptr_t) st
->location
),
6869 /* Return the first static tracepoint, and initialize the state
6870 machine that will iterate through all the static tracepoints. */
6873 cmd_qtfstm (char *packet
)
6875 trace_debug ("Returning first trace state variable definition");
6877 if (first_marker ())
6878 response_ust_marker (packet
, first_marker ());
6880 strcpy (packet
, "l");
6883 /* Return additional trace state variable definitions. */
6886 cmd_qtsstm (char *packet
)
6888 trace_debug ("Returning static tracepoint");
6891 response_ust_marker (packet
, next_st
);
6893 strcpy (packet
, "l");
6896 /* Disconnect the GDB probe from a marker at a given address. */
6899 unprobe_marker_at (char *packet
)
6903 struct marker_iter iter
;
6905 p
+= sizeof ("unprobe_marker_at:") - 1;
6907 p
= unpack_varlen_hex (p
, &address
);
6909 USTF(marker_iter_reset
) (&iter
);
6910 USTF(marker_iter_start
) (&iter
);
6911 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
6912 if ((uintptr_t ) iter
.marker
->location
== address
)
6916 result
= USTF(ltt_marker_disconnect
) (iter
.marker
->channel
,
6920 warning ("could not disable marker %s/%s",
6921 iter
.marker
->channel
, iter
.marker
->name
);
6926 /* Connect the GDB probe to a marker at a given address. */
6929 probe_marker_at (char *packet
)
6933 struct marker_iter iter
;
6936 p
+= sizeof ("probe_marker_at:") - 1;
6938 p
= unpack_varlen_hex (p
, &address
);
6940 USTF(marker_iter_reset
) (&iter
);
6942 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
6944 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
6945 if ((uintptr_t ) m
->location
== address
)
6949 trace_debug ("found marker for address. "
6950 "ltt_marker_connect (marker = %s/%s)",
6951 m
->channel
, m
->name
);
6953 result
= USTF(ltt_marker_connect
) (m
->channel
, m
->name
,
6955 if (result
&& result
!= -EEXIST
)
6956 trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
6957 m
->channel
, m
->name
, -result
);
6961 sprintf (packet
, "E.could not connect marker: channel=%s, name=%s",
6962 m
->channel
, m
->name
);
6966 strcpy (packet
, "OK");
6970 sprintf (packet
, "E.no marker found at 0x%s", paddress (address
));
6975 cmd_qtstmat (char *packet
)
6979 struct marker_iter iter
;
6982 p
+= sizeof ("qTSTMat:") - 1;
6984 p
= unpack_varlen_hex (p
, &address
);
6986 USTF(marker_iter_reset
) (&iter
);
6988 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
6990 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
6991 if ((uintptr_t ) m
->location
== address
)
6993 response_ust_marker (packet
, m
);
6997 strcpy (packet
, "l");
7007 USTF(ltt_probe_register
) (&gdb_ust_probe
);
7010 #endif /* HAVE_UST */
7012 #include <sys/syscall.h>
7016 gdb_agent_remove_socket (void)
7018 unlink (agent_socket_name
);
7021 /* Helper thread of agent. */
7024 gdb_agent_helper_thread (void *arg
)
7028 atexit (gdb_agent_remove_socket
);
7032 listen_fd
= gdb_agent_socket_init ();
7034 if (helper_thread_id
== 0)
7035 helper_thread_id
= syscall (SYS_gettid
);
7037 if (listen_fd
== -1)
7039 warning ("could not create sync socket\n");
7046 struct sockaddr_un sockaddr
;
7052 tmp
= sizeof (sockaddr
);
7056 fd
= accept (listen_fd
, &sockaddr
, &tmp
);
7058 /* It seems an ERESTARTSYS can escape out of accept. */
7059 while (fd
== -512 || (fd
== -1 && errno
== EINTR
));
7063 warning ("Accept returned %d, error: %s\n",
7064 fd
, strerror (errno
));
7070 ret
= read (fd
, buf
, 1);
7071 } while (ret
== -1 && errno
== EINTR
);
7075 warning ("reading socket (fd=%d) failed with %s",
7076 fd
, strerror (errno
));
7083 if (strncmp ("close", cmd_buf
, 5) == 0)
7088 else if (strcmp ("qTfSTM", cmd_buf
) == 0)
7090 cmd_qtfstm (cmd_buf
);
7092 else if (strcmp ("qTsSTM", cmd_buf
) == 0)
7094 cmd_qtsstm (cmd_buf
);
7096 else if (strncmp ("unprobe_marker_at:",
7098 sizeof ("unprobe_marker_at:") - 1) == 0)
7100 unprobe_marker_at (cmd_buf
);
7102 else if (strncmp ("probe_marker_at:",
7104 sizeof ("probe_marker_at:") - 1) == 0)
7106 probe_marker_at (cmd_buf
);
7108 else if (strncmp ("qTSTMat:",
7110 sizeof ("qTSTMat:") - 1) == 0)
7112 cmd_qtstmat (cmd_buf
);
7114 #endif /* HAVE_UST */
7117 /* Fix compiler's warning: ignoring return value of 'write'. */
7118 ret
= write (fd
, buf
, 1);
7124 unlink (agent_socket_name
);
7126 /* Sleep endlessly to wait the whole inferior stops. This
7127 thread can not exit because GDB or GDBserver may still need
7128 'current_inferior' (representing this thread) to access
7129 inferior memory. Otherwise, this thread exits earlier than
7130 other threads, and 'current_inferior' is set to NULL. */
7141 #include <pthread.h>
7143 IP_AGENT_EXPORT
int gdb_agent_capability
= AGENT_CAPA_STATIC_TRACE
;
7146 gdb_agent_init (void)
7153 /* We want the helper thread to be as transparent as possible, so
7154 have it inherit an all-signals-blocked mask. */
7156 sigfillset (&new_mask
);
7157 res
= pthread_sigmask (SIG_SETMASK
, &new_mask
, &orig_mask
);
7159 fatal ("pthread_sigmask (1) failed: %s", strerror (res
));
7161 res
= pthread_create (&thread
,
7163 gdb_agent_helper_thread
,
7166 res
= pthread_sigmask (SIG_SETMASK
, &orig_mask
, NULL
);
7168 fatal ("pthread_sigmask (2) failed: %s", strerror (res
));
7170 while (helper_thread_id
== 0)
7178 #include <sys/mman.h>
7181 IP_AGENT_EXPORT
char *gdb_tp_heap_buffer
;
7182 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer
;
7183 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer_end
;
7184 IP_AGENT_EXPORT
char *gdb_trampoline_buffer
;
7185 IP_AGENT_EXPORT
char *gdb_trampoline_buffer_end
;
7186 IP_AGENT_EXPORT
char *gdb_trampoline_buffer_error
;
7188 /* Record the result of getting buffer space for fast tracepoint
7189 trampolines. Any error message is copied, since caller may not be
7190 using persistent storage. */
7193 set_trampoline_buffer_space (CORE_ADDR begin
, CORE_ADDR end
, char *errmsg
)
7195 gdb_trampoline_buffer
= (char *) (uintptr_t) begin
;
7196 gdb_trampoline_buffer_end
= (char *) (uintptr_t) end
;
7198 strncpy (gdb_trampoline_buffer_error
, errmsg
, 99);
7200 strcpy (gdb_trampoline_buffer_error
, "no buffer passed");
7203 static void __attribute__ ((constructor
))
7204 initialize_tracepoint_ftlib (void)
7206 initialize_tracepoint ();
7211 #endif /* IN_PROCESS_AGENT */
7213 /* Return a timestamp, expressed as microseconds of the usual Unix
7214 time. (As the result is a 64-bit number, it will not overflow any
7218 get_timestamp (void)
7222 if (gettimeofday (&tv
, 0) != 0)
7225 return (LONGEST
) tv
.tv_sec
* 1000000 + tv
.tv_usec
;
7229 initialize_tracepoint (void)
7231 /* There currently no way to change the buffer size. */
7232 const int sizeOfBuffer
= 5 * 1024 * 1024;
7233 unsigned char *buf
= xmalloc (sizeOfBuffer
);
7234 init_trace_buffer (buf
, sizeOfBuffer
);
7236 /* Wire trace state variable 1 to be the timestamp. This will be
7237 uploaded to GDB upon connection and become one of its trace state
7238 variables. (In case you're wondering, if GDB already has a trace
7239 variable numbered 1, it will be renumbered.) */
7240 create_trace_state_variable (1, 0);
7241 set_trace_state_variable_name (1, "trace_timestamp");
7242 set_trace_state_variable_getter (1, get_timestamp
);
7244 #ifdef IN_PROCESS_AGENT
7249 pagesize
= sysconf (_SC_PAGE_SIZE
);
7253 gdb_tp_heap_buffer
= xmalloc (5 * 1024 * 1024);
7255 #define SCRATCH_BUFFER_NPAGES 20
7257 /* Allocate scratch buffer aligned on a page boundary, at a low
7258 address (close to the main executable's code). */
7259 for (addr
= pagesize
; addr
!= 0; addr
+= pagesize
)
7261 gdb_jump_pad_buffer
= mmap ((void *) addr
, pagesize
* SCRATCH_BUFFER_NPAGES
,
7262 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
7263 MAP_PRIVATE
| MAP_ANONYMOUS
| MAP_FIXED
,
7265 if (gdb_jump_pad_buffer
!= MAP_FAILED
)
7271 initialize_tracepoint: mmap'ing jump pad buffer failed with %s",
7274 gdb_jump_pad_buffer_end
= gdb_jump_pad_buffer
+ pagesize
* SCRATCH_BUFFER_NPAGES
;
7277 gdb_trampoline_buffer
= gdb_trampoline_buffer_end
= 0;
7279 /* It's not a fatal error for something to go wrong with trampoline
7280 buffer setup, but it can be mysterious, so create a channel to
7281 report back on what went wrong, using a fixed size since we may
7282 not be able to allocate space later when the problem occurs. */
7283 gdb_trampoline_buffer_error
= xmalloc (IPA_BUFSIZ
);
7285 strcpy (gdb_trampoline_buffer_error
, "No errors reported");
7287 initialize_low_tracepoint ();