1 /* Tracepoint code for remote server for GDB.
2 Copyright (C) 2009-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "tracepoint.h"
21 #include "gdbthread.h"
35 #define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
37 /* This file is built for both GDBserver, and the in-process
38 agent (IPA), a shared library that includes a tracing agent that is
39 loaded by the inferior to support fast tracepoints. Fast
40 tracepoints (or more accurately, jump based tracepoints) are
41 implemented by patching the tracepoint location with a jump into a
42 small trampoline function whose job is to save the register state,
43 call the in-process tracing agent, and then execute the original
44 instruction that was under the tracepoint jump (possibly adjusted,
45 if PC-relative, or some such).
47 The current synchronization design is pull based. That means,
48 GDBserver does most of the work, by peeking/poking at the inferior
49 agent's memory directly for downloading tracepoint and associated
50 objects, and for uploading trace frames. Whenever the IPA needs
51 something from GDBserver (trace buffer is full, tracing stopped for
52 some reason, etc.) the IPA calls a corresponding hook function
53 where GDBserver has placed a breakpoint.
55 Each of the agents has its own trace buffer. When browsing the
56 trace frames built from slow and fast tracepoints from GDB (tfind
57 mode), there's no guarantee the user is seeing the trace frames in
58 strict chronological creation order, although, GDBserver tries to
59 keep the order relatively reasonable, by syncing the trace buffers
64 #ifdef IN_PROCESS_AGENT
66 static void trace_vdebug (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
69 trace_vdebug (const char *fmt
, ...)
75 vsprintf (buf
, fmt
, ap
);
76 fprintf (stderr
, PROG
"/tracepoint: %s\n", buf
);
80 #define trace_debug_1(level, fmt, args...) \
82 if (level <= debug_threads) \
83 trace_vdebug ((fmt), ##args); \
88 #define trace_debug_1(level, fmt, args...) \
90 if (level <= debug_threads) \
92 debug_printf ((fmt), ##args); \
93 debug_printf ("\n"); \
99 #define trace_debug(FMT, args...) \
100 trace_debug_1 (1, FMT, ##args)
102 #if defined(__GNUC__)
103 # define ATTR_USED __attribute__((used))
104 # define ATTR_NOINLINE __attribute__((noinline))
105 # define ATTR_CONSTRUCTOR __attribute__ ((constructor))
108 # define ATTR_NOINLINE
109 # define ATTR_CONSTRUCTOR
112 /* Make sure the functions the IPA needs to export (symbols GDBserver
113 needs to query GDB about) are exported. */
115 #ifdef IN_PROCESS_AGENT
116 # if defined _WIN32 || defined __CYGWIN__
117 # define IP_AGENT_EXPORT __declspec(dllexport) ATTR_USED
120 # define IP_AGENT_EXPORT \
121 __attribute__ ((visibility("default"))) ATTR_USED
123 # define IP_AGENT_EXPORT ATTR_USED
127 # define IP_AGENT_EXPORT
130 /* Prefix exported symbols, for good citizenship. All the symbols
131 that need exporting are defined in this module. */
132 #ifdef IN_PROCESS_AGENT
133 # define gdb_tp_heap_buffer gdb_agent_gdb_tp_heap_buffer
134 # define gdb_jump_pad_buffer gdb_agent_gdb_jump_pad_buffer
135 # define gdb_jump_pad_buffer_end gdb_agent_gdb_jump_pad_buffer_end
136 # define gdb_trampoline_buffer gdb_agent_gdb_trampoline_buffer
137 # define gdb_trampoline_buffer_end gdb_agent_gdb_trampoline_buffer_end
138 # define gdb_trampoline_buffer_error gdb_agent_gdb_trampoline_buffer_error
139 # define collecting gdb_agent_collecting
140 # define gdb_collect gdb_agent_gdb_collect
141 # define stop_tracing gdb_agent_stop_tracing
142 # define flush_trace_buffer gdb_agent_flush_trace_buffer
143 # define about_to_request_buffer_space gdb_agent_about_to_request_buffer_space
144 # define trace_buffer_is_full gdb_agent_trace_buffer_is_full
145 # define stopping_tracepoint gdb_agent_stopping_tracepoint
146 # define expr_eval_result gdb_agent_expr_eval_result
147 # define error_tracepoint gdb_agent_error_tracepoint
148 # define tracepoints gdb_agent_tracepoints
149 # define tracing gdb_agent_tracing
150 # define trace_buffer_ctrl gdb_agent_trace_buffer_ctrl
151 # define trace_buffer_ctrl_curr gdb_agent_trace_buffer_ctrl_curr
152 # define trace_buffer_lo gdb_agent_trace_buffer_lo
153 # define trace_buffer_hi gdb_agent_trace_buffer_hi
154 # define traceframe_read_count gdb_agent_traceframe_read_count
155 # define traceframe_write_count gdb_agent_traceframe_write_count
156 # define traceframes_created gdb_agent_traceframes_created
157 # define trace_state_variables gdb_agent_trace_state_variables
158 # define get_raw_reg gdb_agent_get_raw_reg
159 # define get_trace_state_variable_value \
160 gdb_agent_get_trace_state_variable_value
161 # define set_trace_state_variable_value \
162 gdb_agent_set_trace_state_variable_value
163 # define ust_loaded gdb_agent_ust_loaded
164 # define helper_thread_id gdb_agent_helper_thread_id
165 # define cmd_buf gdb_agent_cmd_buf
168 #ifndef IN_PROCESS_AGENT
170 /* Addresses of in-process agent's symbols GDBserver cares about. */
172 struct ipa_sym_addresses
174 CORE_ADDR addr_gdb_tp_heap_buffer
;
175 CORE_ADDR addr_gdb_jump_pad_buffer
;
176 CORE_ADDR addr_gdb_jump_pad_buffer_end
;
177 CORE_ADDR addr_gdb_trampoline_buffer
;
178 CORE_ADDR addr_gdb_trampoline_buffer_end
;
179 CORE_ADDR addr_gdb_trampoline_buffer_error
;
180 CORE_ADDR addr_collecting
;
181 CORE_ADDR addr_gdb_collect
;
182 CORE_ADDR addr_stop_tracing
;
183 CORE_ADDR addr_flush_trace_buffer
;
184 CORE_ADDR addr_about_to_request_buffer_space
;
185 CORE_ADDR addr_trace_buffer_is_full
;
186 CORE_ADDR addr_stopping_tracepoint
;
187 CORE_ADDR addr_expr_eval_result
;
188 CORE_ADDR addr_error_tracepoint
;
189 CORE_ADDR addr_tracepoints
;
190 CORE_ADDR addr_tracing
;
191 CORE_ADDR addr_trace_buffer_ctrl
;
192 CORE_ADDR addr_trace_buffer_ctrl_curr
;
193 CORE_ADDR addr_trace_buffer_lo
;
194 CORE_ADDR addr_trace_buffer_hi
;
195 CORE_ADDR addr_traceframe_read_count
;
196 CORE_ADDR addr_traceframe_write_count
;
197 CORE_ADDR addr_traceframes_created
;
198 CORE_ADDR addr_trace_state_variables
;
199 CORE_ADDR addr_get_raw_reg
;
200 CORE_ADDR addr_get_trace_state_variable_value
;
201 CORE_ADDR addr_set_trace_state_variable_value
;
202 CORE_ADDR addr_ust_loaded
;
211 IPA_SYM(gdb_tp_heap_buffer
),
212 IPA_SYM(gdb_jump_pad_buffer
),
213 IPA_SYM(gdb_jump_pad_buffer_end
),
214 IPA_SYM(gdb_trampoline_buffer
),
215 IPA_SYM(gdb_trampoline_buffer_end
),
216 IPA_SYM(gdb_trampoline_buffer_error
),
218 IPA_SYM(gdb_collect
),
219 IPA_SYM(stop_tracing
),
220 IPA_SYM(flush_trace_buffer
),
221 IPA_SYM(about_to_request_buffer_space
),
222 IPA_SYM(trace_buffer_is_full
),
223 IPA_SYM(stopping_tracepoint
),
224 IPA_SYM(expr_eval_result
),
225 IPA_SYM(error_tracepoint
),
226 IPA_SYM(tracepoints
),
228 IPA_SYM(trace_buffer_ctrl
),
229 IPA_SYM(trace_buffer_ctrl_curr
),
230 IPA_SYM(trace_buffer_lo
),
231 IPA_SYM(trace_buffer_hi
),
232 IPA_SYM(traceframe_read_count
),
233 IPA_SYM(traceframe_write_count
),
234 IPA_SYM(traceframes_created
),
235 IPA_SYM(trace_state_variables
),
236 IPA_SYM(get_raw_reg
),
237 IPA_SYM(get_trace_state_variable_value
),
238 IPA_SYM(set_trace_state_variable_value
),
242 static struct ipa_sym_addresses ipa_sym_addrs
;
244 static int read_inferior_integer (CORE_ADDR symaddr
, int *val
);
246 /* Returns true if both the in-process agent library and the static
247 tracepoints libraries are loaded in the inferior, and agent has
248 capability on static tracepoints. */
251 in_process_agent_supports_ust (void)
255 if (!agent_loaded_p ())
257 warning ("In-process agent not loaded");
261 if (agent_capability_check (AGENT_CAPA_STATIC_TRACE
))
263 /* Agent understands static tracepoint, then check whether UST is in
264 fact loaded in the inferior. */
265 if (read_inferior_integer (ipa_sym_addrs
.addr_ust_loaded
, &loaded
))
267 warning ("Error reading ust_loaded in lib");
278 write_e_ipa_not_loaded (char *buffer
)
281 "E.In-process agent library not loaded in process. "
282 "Fast and static tracepoints unavailable.");
285 /* Write an error to BUFFER indicating that UST isn't loaded in the
289 write_e_ust_not_loaded (char *buffer
)
293 "E.UST library not loaded in process. "
294 "Static tracepoints unavailable.");
296 sprintf (buffer
, "E.GDBserver was built without static tracepoints support");
300 /* If the in-process agent library isn't loaded in the inferior, write
301 an error to BUFFER, and return 1. Otherwise, return 0. */
304 maybe_write_ipa_not_loaded (char *buffer
)
306 if (!agent_loaded_p ())
308 write_e_ipa_not_loaded (buffer
);
314 /* If the in-process agent library and the ust (static tracepoints)
315 library aren't loaded in the inferior, write an error to BUFFER,
316 and return 1. Otherwise, return 0. */
319 maybe_write_ipa_ust_not_loaded (char *buffer
)
321 if (!agent_loaded_p ())
323 write_e_ipa_not_loaded (buffer
);
326 else if (!in_process_agent_supports_ust ())
328 write_e_ust_not_loaded (buffer
);
334 /* Cache all future symbols that the tracepoints module might request.
335 We can not request symbols at arbitrary states in the remote
336 protocol, only when the client tells us that new symbols are
337 available. So when we load the in-process library, make sure to
338 check the entire list. */
341 tracepoint_look_up_symbols (void)
345 if (agent_loaded_p ())
348 for (i
= 0; i
< sizeof (symbol_list
) / sizeof (symbol_list
[0]); i
++)
351 (CORE_ADDR
*) ((char *) &ipa_sym_addrs
+ symbol_list
[i
].offset
);
353 if (look_up_one_symbol (symbol_list
[i
].name
, addrp
, 1) == 0)
356 debug_printf ("symbol `%s' not found\n", symbol_list
[i
].name
);
361 agent_look_up_symbols (NULL
);
366 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
367 of the "stop_tracing" function. When this breakpoint is hit,
368 tracing stopped in the IPA for some reason. E.g., due to
369 tracepoint reaching the pass count, hitting conditional expression
370 evaluation error, etc.
372 The IPA's trace buffer is never in circular tracing mode: instead,
373 GDBserver's is, and whenever the in-process buffer fills, it calls
374 "flush_trace_buffer", which triggers an internal breakpoint.
375 GDBserver reacts to this breakpoint by pulling the meanwhile
376 collected data. Old frames discarding is always handled on the
379 #ifdef IN_PROCESS_AGENT
381 read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
383 memcpy (myaddr
, (void *) (uintptr_t) memaddr
, len
);
387 /* Call this in the functions where GDBserver places a breakpoint, so
388 that the compiler doesn't try to be clever and skip calling the
389 function at all. This is necessary, even if we tell the compiler
390 to not inline said functions. */
392 #if defined(__GNUC__)
393 # define UNKNOWN_SIDE_EFFECTS() asm ("")
395 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
398 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
401 /* GDBserver places breakpoint here. */
402 UNKNOWN_SIDE_EFFECTS();
405 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
406 flush_trace_buffer (void)
408 /* GDBserver places breakpoint here. */
409 UNKNOWN_SIDE_EFFECTS();
414 #ifndef IN_PROCESS_AGENT
416 tracepoint_handler (CORE_ADDR address
)
418 trace_debug ("tracepoint_handler: tracepoint at 0x%s hit",
423 /* Breakpoint at "stop_tracing" in the inferior lib. */
424 struct breakpoint
*stop_tracing_bkpt
;
425 static int stop_tracing_handler (CORE_ADDR
);
427 /* Breakpoint at "flush_trace_buffer" in the inferior lib. */
428 struct breakpoint
*flush_trace_buffer_bkpt
;
429 static int flush_trace_buffer_handler (CORE_ADDR
);
431 static void download_trace_state_variables (void);
432 static void upload_fast_traceframes (void);
434 static int run_inferior_command (char *cmd
, int len
);
437 read_inferior_integer (CORE_ADDR symaddr
, int *val
)
439 return read_inferior_memory (symaddr
, (unsigned char *) val
,
444 static int tracepoint_send_agent (struct tracepoint
*tpoint
);
447 read_inferior_uinteger (CORE_ADDR symaddr
, unsigned int *val
)
449 return read_inferior_memory (symaddr
, (unsigned char *) val
,
454 read_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR
*val
)
456 void *pval
= (void *) (uintptr_t) val
;
459 ret
= read_inferior_memory (symaddr
, (unsigned char *) &pval
, sizeof (pval
));
460 *val
= (uintptr_t) pval
;
465 write_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR val
)
467 void *pval
= (void *) (uintptr_t) val
;
468 return write_inferior_memory (symaddr
,
469 (unsigned char *) &pval
, sizeof (pval
));
473 write_inferior_integer (CORE_ADDR symaddr
, int val
)
475 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
479 write_inferior_uinteger (CORE_ADDR symaddr
, unsigned int val
)
481 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
484 static CORE_ADDR
target_malloc (ULONGEST size
);
485 static int write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
);
487 #define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
489 memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
490 BUF += sizeof ((OBJ)->FIELD); \
495 /* Operations on various types of tracepoint actions. */
497 struct tracepoint_action
;
499 struct tracepoint_action_ops
501 /* Download tracepoint action ACTION to IPA. Return the address of action
503 CORE_ADDR (*download
) (const struct tracepoint_action
*action
);
505 /* Send ACTION to agent via command buffer started from BUFFER. Return
506 updated head of command buffer. */
507 char* (*send
) (char *buffer
, const struct tracepoint_action
*action
);
510 /* Base action. Concrete actions inherit this. */
512 struct tracepoint_action
514 #ifndef IN_PROCESS_AGENT
515 const struct tracepoint_action_ops
*ops
;
520 /* An 'M' (collect memory) action. */
521 struct collect_memory_action
523 struct tracepoint_action base
;
530 /* An 'R' (collect registers) action. */
532 struct collect_registers_action
534 struct tracepoint_action base
;
537 /* An 'X' (evaluate expression) action. */
539 struct eval_expr_action
541 struct tracepoint_action base
;
543 struct agent_expr
*expr
;
546 /* An 'L' (collect static trace data) action. */
547 struct collect_static_trace_data_action
549 struct tracepoint_action base
;
552 #ifndef IN_PROCESS_AGENT
554 m_tracepoint_action_download (const struct tracepoint_action
*action
)
556 int size_in_ipa
= (sizeof (struct collect_memory_action
)
557 - offsetof (struct tracepoint_action
, type
));
558 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
560 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
566 m_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
568 struct collect_memory_action
*maction
569 = (struct collect_memory_action
*) action
;
571 COPY_FIELD_TO_BUF (buffer
, maction
, addr
);
572 COPY_FIELD_TO_BUF (buffer
, maction
, len
);
573 COPY_FIELD_TO_BUF (buffer
, maction
, basereg
);
578 static const struct tracepoint_action_ops m_tracepoint_action_ops
=
580 m_tracepoint_action_download
,
581 m_tracepoint_action_send
,
585 r_tracepoint_action_download (const struct tracepoint_action
*action
)
587 int size_in_ipa
= (sizeof (struct collect_registers_action
)
588 - offsetof (struct tracepoint_action
, type
));
589 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
591 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
598 r_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
603 static const struct tracepoint_action_ops r_tracepoint_action_ops
=
605 r_tracepoint_action_download
,
606 r_tracepoint_action_send
,
609 static CORE_ADDR
download_agent_expr (struct agent_expr
*expr
);
612 x_tracepoint_action_download (const struct tracepoint_action
*action
)
614 int size_in_ipa
= (sizeof (struct eval_expr_action
)
615 - offsetof (struct tracepoint_action
, type
));
616 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
619 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
621 expr
= download_agent_expr (((struct eval_expr_action
*)action
)->expr
);
622 write_inferior_data_ptr (ipa_action
+ offsetof (struct eval_expr_action
, expr
)
623 - offsetof (struct tracepoint_action
, type
),
629 /* Copy agent expression AEXPR to buffer pointed by P. If AEXPR is NULL,
630 copy 0 to P. Return updated header of buffer. */
633 agent_expr_send (char *p
, const struct agent_expr
*aexpr
)
635 /* Copy the length of condition first, and then copy its
644 memcpy (p
, &aexpr
->length
, 4);
647 memcpy (p
, aexpr
->bytes
, aexpr
->length
);
654 x_tracepoint_action_send ( char *buffer
, const struct tracepoint_action
*action
)
656 struct eval_expr_action
*eaction
= (struct eval_expr_action
*) action
;
658 return agent_expr_send (buffer
, eaction
->expr
);
661 static const struct tracepoint_action_ops x_tracepoint_action_ops
=
663 x_tracepoint_action_download
,
664 x_tracepoint_action_send
,
668 l_tracepoint_action_download (const struct tracepoint_action
*action
)
670 int size_in_ipa
= (sizeof (struct collect_static_trace_data_action
)
671 - offsetof (struct tracepoint_action
, type
));
672 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
674 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
681 l_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
686 static const struct tracepoint_action_ops l_tracepoint_action_ops
=
688 l_tracepoint_action_download
,
689 l_tracepoint_action_send
,
693 /* This structure describes a piece of the source-level definition of
694 the tracepoint. The contents are not interpreted by the target,
695 but preserved verbatim for uploading upon reconnection. */
699 /* The type of string, such as "cond" for a conditional. */
702 /* The source-level string itself. For the sake of target
703 debugging, we store it in plaintext, even though it is always
704 transmitted in hex. */
707 /* Link to the next one in the list. We link them in the order
708 received, in case some make up an ordered list of commands or
710 struct source_string
*next
;
715 /* Trap based tracepoint. */
718 /* A fast tracepoint implemented with a jump instead of a trap. */
721 /* A static tracepoint, implemented by a program call into a tracing
726 struct tracepoint_hit_ctx
;
728 typedef enum eval_result_type (*condfn
) (struct tracepoint_hit_ctx
*,
731 /* The definition of a tracepoint. */
733 /* Tracepoints may have multiple locations, each at a different
734 address. This can occur with optimizations, template
735 instantiation, etc. Since the locations may be in different
736 scopes, the conditions and actions may be different for each
737 location. Our target version of tracepoints is more like GDB's
738 notion of "breakpoint locations", but we have almost nothing that
739 is not per-location, so we bother having two kinds of objects. The
740 key consequence is that numbers are not unique, and that it takes
741 both number and address to identify a tracepoint uniquely. */
745 /* The number of the tracepoint, as specified by GDB. Several
746 tracepoint objects here may share a number. */
749 /* Address at which the tracepoint is supposed to trigger. Several
750 tracepoints may share an address. */
753 /* Tracepoint type. */
754 enum tracepoint_type type
;
756 /* True if the tracepoint is currently enabled. */
759 /* The number of single steps that will be performed after each
763 /* The number of times the tracepoint may be hit before it will
764 terminate the entire tracing run. */
767 /* Pointer to the agent expression that is the tracepoint's
768 conditional, or NULL if the tracepoint is unconditional. */
769 struct agent_expr
*cond
;
771 /* The list of actions to take when the tracepoint triggers. */
773 struct tracepoint_action
**actions
;
775 /* Count of the times we've hit this tracepoint during the run.
776 Note that while-stepping steps are not counted as "hits". */
779 /* Cached sum of the sizes of traceframes created by this point. */
780 uint64_t traceframe_usage
;
782 CORE_ADDR compiled_cond
;
784 /* Link to the next tracepoint in the list. */
785 struct tracepoint
*next
;
787 #ifndef IN_PROCESS_AGENT
788 /* The list of actions to take when the tracepoint triggers, in
789 string/packet form. */
792 /* The collection of strings that describe the tracepoint as it was
793 entered into GDB. These are not used by the target, but are
794 reported back to GDB upon reconnection. */
795 struct source_string
*source_strings
;
797 /* The number of bytes displaced by fast tracepoints. It may subsume
798 multiple instructions, for multi-byte fast tracepoints. This
799 field is only valid for fast tracepoints. */
802 /* Only for fast tracepoints. */
803 CORE_ADDR obj_addr_on_target
;
805 /* Address range where the original instruction under a fast
806 tracepoint was relocated to. (_end is actually one byte past
808 CORE_ADDR adjusted_insn_addr
;
809 CORE_ADDR adjusted_insn_addr_end
;
811 /* The address range of the piece of the jump pad buffer that was
812 assigned to this fast tracepoint. (_end is actually one byte
815 CORE_ADDR jump_pad_end
;
817 /* The address range of the piece of the trampoline buffer that was
818 assigned to this fast tracepoint. (_end is actually one byte
820 CORE_ADDR trampoline
;
821 CORE_ADDR trampoline_end
;
823 /* The list of actions to take while in a stepping loop. These
824 fields are only valid for patch-based tracepoints. */
825 int num_step_actions
;
826 struct tracepoint_action
**step_actions
;
827 /* Same, but in string/packet form. */
828 char **step_actions_str
;
830 /* Handle returned by the breakpoint or tracepoint module when we
831 inserted the trap or jump, or hooked into a static tracepoint.
832 NULL if we haven't inserted it yet. */
838 #ifndef IN_PROCESS_AGENT
840 /* Given `while-stepping', a thread may be collecting data for more
841 than one tracepoint simultaneously. On the other hand, the same
842 tracepoint with a while-stepping action may be hit by more than one
843 thread simultaneously (but not quite, each thread could be handling
844 a different step). Each thread holds a list of these objects,
845 representing the current step of each while-stepping action being
850 struct wstep_state
*next
;
852 /* The tracepoint number. */
854 /* The tracepoint's address. */
855 CORE_ADDR tp_address
;
857 /* The number of the current step in this 'while-stepping'
864 /* The linked list of all tracepoints. Marked explicitly as used as
865 the in-process library doesn't use it for the fast tracepoints
867 IP_AGENT_EXPORT
struct tracepoint
*tracepoints ATTR_USED
;
869 #ifndef IN_PROCESS_AGENT
871 /* Pointer to the last tracepoint in the list, new tracepoints are
872 linked in at the end. */
874 static struct tracepoint
*last_tracepoint
;
877 /* The first tracepoint to exceed its pass count. */
879 IP_AGENT_EXPORT
struct tracepoint
*stopping_tracepoint
;
881 /* True if the trace buffer is full or otherwise no longer usable. */
883 IP_AGENT_EXPORT
int trace_buffer_is_full
;
885 static enum eval_result_type expr_eval_result
= expr_eval_no_error
;
887 #ifndef IN_PROCESS_AGENT
889 static const char *eval_result_names
[] =
891 "terror:in the attic", /* this should never be reported */
892 "terror:empty expression",
893 "terror:empty stack",
894 "terror:stack overflow",
895 "terror:stack underflow",
896 "terror:unhandled opcode",
897 "terror:unrecognized opcode",
898 "terror:divide by zero"
903 /* The tracepoint in which the error occurred. */
905 static struct tracepoint
*error_tracepoint
;
907 struct trace_state_variable
909 /* This is the name of the variable as used in GDB. The target
910 doesn't use the name, but needs to have it for saving and
911 reconnection purposes. */
914 /* This number identifies the variable uniquely. Numbers may be
915 assigned either by the target (in the case of builtin variables),
916 or by GDB, and are presumed unique during the course of a trace
920 /* The variable's initial value, a 64-bit signed integer always. */
921 LONGEST initial_value
;
923 /* The variable's value, a 64-bit signed integer always. */
926 /* Pointer to a getter function, used to supply computed values. */
927 LONGEST (*getter
) (void);
929 /* Link to the next variable. */
930 struct trace_state_variable
*next
;
933 /* Linked list of all trace state variables. */
935 #ifdef IN_PROCESS_AGENT
936 struct trace_state_variable
*alloced_trace_state_variables
;
939 IP_AGENT_EXPORT
struct trace_state_variable
*trace_state_variables
;
941 /* The results of tracing go into a fixed-size space known as the
942 "trace buffer". Because usage follows a limited number of
943 patterns, we manage it ourselves rather than with malloc. Basic
944 rules are that we create only one trace frame at a time, each is
945 variable in size, they are never moved once created, and we only
946 discard if we are doing a circular buffer, and then only the oldest
947 ones. Each trace frame includes its own size, so we don't need to
948 link them together, and the trace frame number is relative to the
949 first one, so we don't need to record numbers. A trace frame also
950 records the number of the tracepoint that created it. The data
951 itself is a series of blocks, each introduced by a single character
952 and with a defined format. Each type of block has enough
953 type/length info to allow scanners to jump quickly from one block
954 to the next without reading each byte in the block. */
956 /* Trace buffer management would be simple - advance a free pointer
957 from beginning to end, then stop - were it not for the circular
958 buffer option, which is a useful way to prevent a trace run from
959 stopping prematurely because the buffer filled up. In the circular
960 case, the location of the first trace frame (trace_buffer_start)
961 moves as old trace frames are discarded. Also, since we grow trace
962 frames incrementally as actions are performed, we wrap around to
963 the beginning of the trace buffer. This is per-block, so each
964 block within a trace frame remains contiguous. Things get messy
965 when the wrapped-around trace frame is the one being discarded; the
966 free space ends up in two parts at opposite ends of the buffer. */
969 # if defined(__GNUC__)
970 # define ATTR_PACKED __attribute__ ((packed))
972 # define ATTR_PACKED /* nothing */
976 /* The data collected at a tracepoint hit. This object should be as
977 small as possible, since there may be a great many of them. We do
978 not need to keep a frame number, because they are all sequential
979 and there are no deletions; so the Nth frame in the buffer is
980 always frame number N. */
984 /* Number of the tracepoint that collected this traceframe. A value
985 of 0 indicates the current end of the trace buffer. We make this
986 a 16-bit field because it's never going to happen that GDB's
987 numbering of tracepoints reaches 32,000. */
990 /* The size of the data in this trace frame. We limit this to 32
991 bits, even on a 64-bit target, because it's just implausible that
992 one is validly going to collect 4 gigabytes of data at a single
994 unsigned int data_size
: 32;
996 /* The base of the trace data, which is contiguous from this point. */
997 unsigned char data
[0];
1001 /* The size of the EOB marker, in bytes. A traceframe with zeroed
1002 fields (and no data) marks the end of trace data. */
1003 #define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
1005 /* The traceframe to be used as the source of data to send back to
1006 GDB. A value of -1 means to get data from the live program. */
1008 int current_traceframe
= -1;
1010 /* This flag is true if the trace buffer is circular, meaning that
1011 when it fills, the oldest trace frames are discarded in order to
1014 #ifndef IN_PROCESS_AGENT
1015 static int circular_trace_buffer
;
1018 /* Size of the trace buffer. */
1020 static LONGEST trace_buffer_size
;
1022 /* Pointer to the block of memory that traceframes all go into. */
1024 static unsigned char *trace_buffer_lo
;
1026 /* Pointer to the end of the trace buffer, more precisely to the byte
1027 after the end of the buffer. */
1029 static unsigned char *trace_buffer_hi
;
1031 /* Control structure holding the read/write/etc. pointers into the
1032 trace buffer. We need more than one of these to implement a
1033 transaction-like mechanism to garantees that both GDBserver and the
1034 in-process agent can try to change the trace buffer
1037 struct trace_buffer_control
1039 /* Pointer to the first trace frame in the buffer. In the
1040 non-circular case, this is equal to trace_buffer_lo, otherwise it
1041 moves around in the buffer. */
1042 unsigned char *start
;
1044 /* Pointer to the free part of the trace buffer. Note that we clear
1045 several bytes at and after this pointer, so that traceframe
1046 scans/searches terminate properly. */
1047 unsigned char *free
;
1049 /* Pointer to the byte after the end of the free part. Note that
1050 this may be smaller than trace_buffer_free in the circular case,
1051 and means that the free part is in two pieces. Initially it is
1052 equal to trace_buffer_hi, then is generally equivalent to
1053 trace_buffer_start. */
1054 unsigned char *end_free
;
1056 /* Pointer to the wraparound. If not equal to trace_buffer_hi, then
1057 this is the point at which the trace data breaks, and resumes at
1059 unsigned char *wrap
;
1062 /* Same as above, to be used by GDBserver when updating the in-process
1064 struct ipa_trace_buffer_control
1073 /* We have possibly both GDBserver and an inferior thread accessing
1074 the same IPA trace buffer memory. The IPA is the producer (tries
1075 to put new frames in the buffer), while GDBserver occasionally
1076 consumes them, that is, flushes the IPA's buffer into its own
1077 buffer. Both sides need to update the trace buffer control
1078 pointers (current head, tail, etc.). We can't use a global lock to
1079 synchronize the accesses, as otherwise we could deadlock GDBserver
1080 (if the thread holding the lock stops for a signal, say). So
1081 instead of that, we use a transaction scheme where GDBserver writes
1082 always prevail over the IPAs writes, and, we have the IPA detect
1083 the commit failure/overwrite, and retry the whole attempt. This is
1084 mainly implemented by having a global token object that represents
1085 who wrote last to the buffer control structure. We need to freeze
1086 any inferior writing to the buffer while GDBserver touches memory,
1087 so that the inferior can correctly detect that GDBserver had been
1088 there, otherwise, it could mistakingly think its commit was
1089 successful; that's implemented by simply having GDBserver set a
1090 breakpoint the inferior hits if it is the critical region.
1092 There are three cycling trace buffer control structure copies
1093 (buffer head, tail, etc.), with the token object including an index
1094 indicating which is current live copy. The IPA tentatively builds
1095 an updated copy in a non-current control structure, while GDBserver
1096 always clobbers the current version directly. The IPA then tries
1097 to atomically "commit" its version; if GDBserver clobbered the
1098 structure meanwhile, that will fail, and the IPA restarts the
1101 Listing the step in further detail, we have:
1103 In-process agent (producer):
1105 - passes by `about_to_request_buffer_space' breakpoint/lock
1107 - reads current token, extracts current trace buffer control index,
1108 and starts tentatively updating the rightmost one (0->1, 1->2,
1109 2->0). Note that only one inferior thread is executing this code
1110 at any given time, due to an outer lock in the jump pads.
1112 - updates counters, and tries to commit the token.
1114 - passes by second `about_to_request_buffer_space' breakpoint/lock,
1115 leaving the sync region.
1117 - checks if the update was effective.
1119 - if trace buffer was found full, hits flush_trace_buffer
1120 breakpoint, and restarts later afterwards.
1122 GDBserver (consumer):
1124 - sets `about_to_request_buffer_space' breakpoint/lock.
1126 - updates the token unconditionally, using the current buffer
1127 control index, since it knows that the IP agent always writes to
1128 the rightmost, and due to the breakpoint, at most one IP thread
1129 can try to update the trace buffer concurrently to GDBserver, so
1130 there will be no danger of trace buffer control index wrap making
1131 the IPA write to the same index as GDBserver.
1133 - flushes the IP agent's trace buffer completely, and updates the
1134 current trace buffer control structure. GDBserver *always* wins.
1136 - removes the `about_to_request_buffer_space' breakpoint.
1138 The token is stored in the `trace_buffer_ctrl_curr' variable.
1139 Internally, it's bits are defined as:
1141 |-------------+-----+-------------+--------+-------------+--------------|
1142 | Bit offsets | 31 | 30 - 20 | 19 | 18-8 | 7-0 |
1143 |-------------+-----+-------------+--------+-------------+--------------|
1144 | What | GSB | PC (11-bit) | unused | CC (11-bit) | TBCI (8-bit) |
1145 |-------------+-----+-------------+--------+-------------+--------------|
1147 GSB - GDBserver Stamp Bit
1148 PC - Previous Counter
1149 CC - Current Counter
1150 TBCI - Trace Buffer Control Index
1153 An IPA update of `trace_buffer_ctrl_curr' does:
1155 - read CC from the current token, save as PC.
1157 - atomically tries to write PC+1,CC
1159 A GDBserver update of `trace_buffer_ctrl_curr' does:
1161 - reads PC and CC from the current token.
1166 /* These are the bits of `trace_buffer_ctrl_curr' that are reserved
1167 for the counters described below. The cleared bits are used to
1168 hold the index of the items of the `trace_buffer_ctrl' array that
1170 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1172 /* `trace_buffer_ctrl_curr' contains two counters. The `previous'
1173 counter, and the `current' counter. */
1175 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1176 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1178 /* When GDBserver update the IP agent's `trace_buffer_ctrl_curr', it
1179 always stamps this bit as set. */
1180 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1182 #ifdef IN_PROCESS_AGENT
1183 IP_AGENT_EXPORT
struct trace_buffer_control trace_buffer_ctrl
[3];
1184 IP_AGENT_EXPORT
unsigned int trace_buffer_ctrl_curr
;
1186 # define TRACE_BUFFER_CTRL_CURR \
1187 (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1191 /* The GDBserver side agent only needs one instance of this object, as
1192 it doesn't need to sync with itself. Define it as array anyway so
1193 that the rest of the code base doesn't need to care for the
1195 struct trace_buffer_control trace_buffer_ctrl
[1];
1196 # define TRACE_BUFFER_CTRL_CURR 0
1199 /* These are convenience macros used to access the current trace
1200 buffer control in effect. */
1201 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1202 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1203 #define trace_buffer_end_free \
1204 (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1205 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1208 /* Macro that returns a pointer to the first traceframe in the buffer. */
1210 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1212 /* Macro that returns a pointer to the next traceframe in the buffer.
1213 If the computed location is beyond the wraparound point, subtract
1214 the offset of the wraparound. */
1216 #define NEXT_TRACEFRAME_1(TF) \
1217 (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1219 #define NEXT_TRACEFRAME(TF) \
1220 ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1221 - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1222 ? (trace_buffer_wrap - trace_buffer_lo) \
1225 /* The difference between these counters represents the total number
1226 of complete traceframes present in the trace buffer. The IP agent
1227 writes to the write count, GDBserver writes to read count. */
1229 IP_AGENT_EXPORT
unsigned int traceframe_write_count
;
1230 IP_AGENT_EXPORT
unsigned int traceframe_read_count
;
1232 /* Convenience macro. */
1234 #define traceframe_count \
1235 ((unsigned int) (traceframe_write_count - traceframe_read_count))
1237 /* The count of all traceframes created in the current run, including
1238 ones that were discarded to make room. */
1240 IP_AGENT_EXPORT
int traceframes_created
;
1242 #ifndef IN_PROCESS_AGENT
1244 /* Read-only regions are address ranges whose contents don't change,
1245 and so can be read from target memory even while looking at a trace
1246 frame. Without these, disassembly for instance will likely fail,
1247 because the program code is not usually collected into a trace
1248 frame. This data structure does not need to be very complicated or
1249 particularly efficient, it's only going to be used occasionally,
1250 and only by some commands. */
1252 struct readonly_region
1254 /* The bounds of the region. */
1255 CORE_ADDR start
, end
;
1257 /* Link to the next one. */
1258 struct readonly_region
*next
;
1261 /* Linked list of readonly regions. This list stays in effect from
1262 one tstart to the next. */
1264 static struct readonly_region
*readonly_regions
;
1268 /* The global that controls tracing overall. */
1270 IP_AGENT_EXPORT
int tracing
;
1272 #ifndef IN_PROCESS_AGENT
1274 /* Controls whether tracing should continue after GDB disconnects. */
1276 int disconnected_tracing
;
1278 /* The reason for the last tracing run to have stopped. We initialize
1279 to a distinct string so that GDB can distinguish between "stopped
1280 after running" and "stopped because never run" cases. */
1282 static const char *tracing_stop_reason
= "tnotrun";
1284 static int tracing_stop_tpnum
;
1286 /* 64-bit timestamps for the trace run's start and finish, expressed
1287 in microseconds from the Unix epoch. */
1289 LONGEST tracing_start_time
;
1290 LONGEST tracing_stop_time
;
1292 /* The (optional) user-supplied name of the user that started the run.
1293 This is an arbitrary string, and may be NULL. */
1295 char *tracing_user_name
;
1297 /* Optional user-supplied text describing the run. This is
1298 an arbitrary string, and may be NULL. */
1300 char *tracing_notes
;
1302 /* Optional user-supplied text explaining a tstop command. This is an
1303 arbitrary string, and may be NULL. */
1305 char *tracing_stop_note
;
1309 /* Functions local to this file. */
1311 /* Base "class" for tracepoint type specific data to be passed down to
1312 collect_data_at_tracepoint. */
1313 struct tracepoint_hit_ctx
1315 enum tracepoint_type type
;
1318 #ifdef IN_PROCESS_AGENT
1320 /* Fast/jump tracepoint specific data to be passed down to
1321 collect_data_at_tracepoint. */
1322 struct fast_tracepoint_ctx
1324 struct tracepoint_hit_ctx base
;
1326 struct regcache regcache
;
1327 int regcache_initted
;
1328 unsigned char *regspace
;
1330 unsigned char *regs
;
1331 struct tracepoint
*tpoint
;
1334 /* Static tracepoint specific data to be passed down to
1335 collect_data_at_tracepoint. */
1336 struct static_tracepoint_ctx
1338 struct tracepoint_hit_ctx base
;
1340 /* The regcache corresponding to the registers state at the time of
1341 the tracepoint hit. Initialized lazily, from REGS. */
1342 struct regcache regcache
;
1343 int regcache_initted
;
1345 /* The buffer space REGCACHE above uses. We use a separate buffer
1346 instead of letting the regcache malloc for both signal safety and
1347 performance reasons; this is allocated on the stack instead. */
1348 unsigned char *regspace
;
1350 /* The register buffer as passed on by lttng/ust. */
1351 struct registers
*regs
;
1353 /* The "printf" formatter and the args the user passed to the marker
1354 call. We use this to be able to collect "static trace data"
1359 /* The GDB tracepoint matching the probed marker that was "hit". */
1360 struct tracepoint
*tpoint
;
1365 /* Static tracepoint specific data to be passed down to
1366 collect_data_at_tracepoint. */
1367 struct trap_tracepoint_ctx
1369 struct tracepoint_hit_ctx base
;
1371 struct regcache
*regcache
;
1376 #ifndef IN_PROCESS_AGENT
1377 static CORE_ADDR
traceframe_get_pc (struct traceframe
*tframe
);
1378 static int traceframe_read_tsv (int num
, LONGEST
*val
);
1381 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1382 struct tracepoint
*tpoint
);
1384 #ifndef IN_PROCESS_AGENT
1385 static void clear_readonly_regions (void);
1386 static void clear_installed_tracepoints (void);
1389 static void collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1391 struct tracepoint
*tpoint
);
1392 #ifndef IN_PROCESS_AGENT
1393 static void collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
1395 struct tracepoint
*tpoint
, int current_step
);
1396 static void compile_tracepoint_condition (struct tracepoint
*tpoint
,
1397 CORE_ADDR
*jump_entry
);
1399 static void do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1401 struct tracepoint
*tpoint
,
1402 struct traceframe
*tframe
,
1403 struct tracepoint_action
*taction
);
1405 #ifndef IN_PROCESS_AGENT
1406 static struct tracepoint
*fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR
);
1408 static void install_tracepoint (struct tracepoint
*, char *own_buf
);
1409 static void download_tracepoint (struct tracepoint
*);
1410 static int install_fast_tracepoint (struct tracepoint
*, char *errbuf
);
1411 static void clone_fast_tracepoint (struct tracepoint
*to
,
1412 const struct tracepoint
*from
);
1415 static LONGEST
get_timestamp (void);
1417 #if defined(__GNUC__)
1418 # define memory_barrier() asm volatile ("" : : : "memory")
1420 # define memory_barrier() do {} while (0)
1423 /* We only build the IPA if this builtin is supported, and there are
1424 no uses of this in GDBserver itself, so we're safe in defining this
1426 #define cmpxchg(mem, oldval, newval) \
1427 __sync_val_compare_and_swap (mem, oldval, newval)
1429 /* Record that an error occurred during expression evaluation. */
1432 record_tracepoint_error (struct tracepoint
*tpoint
, const char *which
,
1433 enum eval_result_type rtype
)
1435 trace_debug ("Tracepoint %d at %s %s eval reports error %d",
1436 tpoint
->number
, paddress (tpoint
->address
), which
, rtype
);
1438 #ifdef IN_PROCESS_AGENT
1439 /* Only record the first error we get. */
1440 if (cmpxchg (&expr_eval_result
,
1442 rtype
) != expr_eval_no_error
)
1445 if (expr_eval_result
!= expr_eval_no_error
)
1449 error_tracepoint
= tpoint
;
1452 /* Trace buffer management. */
1455 clear_trace_buffer (void)
1457 trace_buffer_start
= trace_buffer_lo
;
1458 trace_buffer_free
= trace_buffer_lo
;
1459 trace_buffer_end_free
= trace_buffer_hi
;
1460 trace_buffer_wrap
= trace_buffer_hi
;
1461 /* A traceframe with zeroed fields marks the end of trace data. */
1462 ((struct traceframe
*) trace_buffer_free
)->tpnum
= 0;
1463 ((struct traceframe
*) trace_buffer_free
)->data_size
= 0;
1464 traceframe_read_count
= traceframe_write_count
= 0;
1465 traceframes_created
= 0;
1468 #ifndef IN_PROCESS_AGENT
1471 clear_inferior_trace_buffer (void)
1473 CORE_ADDR ipa_trace_buffer_lo
;
1474 CORE_ADDR ipa_trace_buffer_hi
;
1475 struct traceframe ipa_traceframe
= { 0 };
1476 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
1478 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
1479 &ipa_trace_buffer_lo
);
1480 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
1481 &ipa_trace_buffer_hi
);
1483 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
1484 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
1485 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
1486 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
1488 /* A traceframe with zeroed fields marks the end of trace data. */
1489 write_inferior_memory (ipa_sym_addrs
.addr_trace_buffer_ctrl
,
1490 (unsigned char *) &ipa_trace_buffer_ctrl
,
1491 sizeof (ipa_trace_buffer_ctrl
));
1493 write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
, 0);
1495 /* A traceframe with zeroed fields marks the end of trace data. */
1496 write_inferior_memory (ipa_trace_buffer_lo
,
1497 (unsigned char *) &ipa_traceframe
,
1498 sizeof (ipa_traceframe
));
1500 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
, 0);
1501 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
, 0);
1502 write_inferior_integer (ipa_sym_addrs
.addr_traceframes_created
, 0);
1508 init_trace_buffer (LONGEST bufsize
)
1512 trace_buffer_size
= bufsize
;
1514 /* Make sure to internally allocate at least space for the EOB
1516 alloc_size
= (bufsize
< TRACEFRAME_EOB_MARKER_SIZE
1517 ? TRACEFRAME_EOB_MARKER_SIZE
: bufsize
);
1518 trace_buffer_lo
= xrealloc (trace_buffer_lo
, alloc_size
);
1520 trace_buffer_hi
= trace_buffer_lo
+ trace_buffer_size
;
1522 clear_trace_buffer ();
1525 #ifdef IN_PROCESS_AGENT
1527 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
1528 about_to_request_buffer_space (void)
1530 /* GDBserver places breakpoint here while it goes about to flush
1531 data at random times. */
1532 UNKNOWN_SIDE_EFFECTS();
1537 /* Carve out a piece of the trace buffer, returning NULL in case of
1541 trace_buffer_alloc (size_t amt
)
1543 unsigned char *rslt
;
1544 struct trace_buffer_control
*tbctrl
;
1546 #ifdef IN_PROCESS_AGENT
1547 unsigned int prev
, prev_filtered
;
1548 unsigned int commit_count
;
1549 unsigned int commit
;
1550 unsigned int readout
;
1552 struct traceframe
*oldest
;
1553 unsigned char *new_start
;
1556 trace_debug ("Want to allocate %ld+%ld bytes in trace buffer",
1557 (long) amt
, (long) sizeof (struct traceframe
));
1559 /* Account for the EOB marker. */
1560 amt
+= TRACEFRAME_EOB_MARKER_SIZE
;
1562 #ifdef IN_PROCESS_AGENT
1566 /* Read the current token and extract the index to try to write to,
1567 storing it in CURR. */
1568 prev
= trace_buffer_ctrl_curr
;
1569 prev_filtered
= prev
& ~GDBSERVER_FLUSH_COUNT_MASK
;
1570 curr
= prev_filtered
+ 1;
1574 about_to_request_buffer_space ();
1576 /* Start out with a copy of the current state. GDBserver may be
1577 midway writing to the PREV_FILTERED TBC, but, that's OK, we won't
1578 be able to commit anyway if that happens. */
1579 trace_buffer_ctrl
[curr
]
1580 = trace_buffer_ctrl
[prev_filtered
];
1581 trace_debug ("trying curr=%u", curr
);
1583 /* The GDBserver's agent doesn't need all that syncing, and always
1584 updates TCB 0 (there's only one, mind you). */
1587 tbctrl
= &trace_buffer_ctrl
[curr
];
1589 /* Offsets are easier to grok for debugging than raw addresses,
1590 especially for the small trace buffer sizes that are useful for
1592 trace_debug ("Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1594 (int) (tbctrl
->start
- trace_buffer_lo
),
1595 (int) (tbctrl
->free
- trace_buffer_lo
),
1596 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1597 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1598 (int) (trace_buffer_hi
- trace_buffer_lo
));
1600 /* The algorithm here is to keep trying to get a contiguous block of
1601 the requested size, possibly discarding older traceframes to free
1602 up space. Since free space might come in one or two pieces,
1603 depending on whether discarded traceframes wrapped around at the
1604 high end of the buffer, we test both pieces after each
1608 /* First, if we have two free parts, try the upper one first. */
1609 if (tbctrl
->end_free
< tbctrl
->free
)
1611 if (tbctrl
->free
+ amt
<= trace_buffer_hi
)
1612 /* We have enough in the upper part. */
1616 /* Our high part of free space wasn't enough. Give up
1617 on it for now, set wraparound. We will recover the
1618 space later, if/when the wrapped-around traceframe is
1620 trace_debug ("Upper part too small, setting wraparound");
1621 tbctrl
->wrap
= tbctrl
->free
;
1622 tbctrl
->free
= trace_buffer_lo
;
1626 /* The normal case. */
1627 if (tbctrl
->free
+ amt
<= tbctrl
->end_free
)
1630 #ifdef IN_PROCESS_AGENT
1631 /* The IP Agent's buffer is always circular. It isn't used
1632 currently, but `circular_trace_buffer' could represent
1633 GDBserver's mode. If we didn't find space, ask GDBserver to
1636 flush_trace_buffer ();
1640 trace_debug ("gdbserver flushed buffer, retrying");
1644 /* GDBserver cancelled the tracing. Bail out as well. */
1647 /* If we're here, then neither part is big enough, and
1648 non-circular trace buffers are now full. */
1649 if (!circular_trace_buffer
)
1651 trace_debug ("Not enough space in the trace buffer");
1655 trace_debug ("Need more space in the trace buffer");
1657 /* If we have a circular buffer, we can try discarding the
1658 oldest traceframe and see if that helps. */
1659 oldest
= FIRST_TRACEFRAME ();
1660 if (oldest
->tpnum
== 0)
1662 /* Not good; we have no traceframes to free. Perhaps we're
1663 asking for a block that is larger than the buffer? In
1664 any case, give up. */
1665 trace_debug ("No traceframes to discard");
1669 /* We don't run this code in the in-process agent currently.
1670 E.g., we could leave the in-process agent in autonomous
1671 circular mode if we only have fast tracepoints. If we do
1672 that, then this bit becomes racy with GDBserver, which also
1673 writes to this counter. */
1674 --traceframe_write_count
;
1676 new_start
= (unsigned char *) NEXT_TRACEFRAME (oldest
);
1677 /* If we freed the traceframe that wrapped around, go back
1678 to the non-wrap case. */
1679 if (new_start
< tbctrl
->start
)
1681 trace_debug ("Discarding past the wraparound");
1682 tbctrl
->wrap
= trace_buffer_hi
;
1684 tbctrl
->start
= new_start
;
1685 tbctrl
->end_free
= tbctrl
->start
;
1687 trace_debug ("Discarded a traceframe\n"
1688 "Trace buffer [%d], start=%d free=%d "
1689 "endfree=%d wrap=%d hi=%d",
1691 (int) (tbctrl
->start
- trace_buffer_lo
),
1692 (int) (tbctrl
->free
- trace_buffer_lo
),
1693 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1694 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1695 (int) (trace_buffer_hi
- trace_buffer_lo
));
1697 /* Now go back around the loop. The discard might have resulted
1698 in either one or two pieces of free space, so we want to try
1699 both before freeing any more traceframes. */
1703 /* If we get here, we know we can provide the asked-for space. */
1705 rslt
= tbctrl
->free
;
1707 /* Adjust the request back down, now that we know we have space for
1708 the marker, but don't commit to AMT yet, we may still need to
1709 restart the operation if GDBserver touches the trace buffer
1710 (obviously only important in the in-process agent's version). */
1711 tbctrl
->free
+= (amt
- sizeof (struct traceframe
));
1713 /* Or not. If GDBserver changed the trace buffer behind our back,
1714 we get to restart a new allocation attempt. */
1716 #ifdef IN_PROCESS_AGENT
1717 /* Build the tentative token. */
1718 commit_count
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) + 0x100)
1719 & GDBSERVER_FLUSH_COUNT_MASK_CURR
);
1720 commit
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) << 12)
1724 /* Try to commit it. */
1725 readout
= cmpxchg (&trace_buffer_ctrl_curr
, prev
, commit
);
1726 if (readout
!= prev
)
1728 trace_debug ("GDBserver has touched the trace buffer, restarting."
1729 " (prev=%08x, commit=%08x, readout=%08x)",
1730 prev
, commit
, readout
);
1734 /* Hold your horses here. Even if that change was committed,
1735 GDBserver could come in, and clobber it. We need to hold to be
1736 able to tell if GDBserver clobbers before or after we committed
1737 the change. Whenever GDBserver goes about touching the IPA
1738 buffer, it sets a breakpoint in this routine, so we have a sync
1740 about_to_request_buffer_space ();
1742 /* Check if the change has been effective, even if GDBserver stopped
1743 us at the breakpoint. */
1746 unsigned int refetch
;
1750 refetch
= trace_buffer_ctrl_curr
;
1752 if (refetch
== commit
1753 || ((refetch
& GDBSERVER_FLUSH_COUNT_MASK_PREV
) >> 12) == commit_count
)
1756 trace_debug ("change is effective: (prev=%08x, commit=%08x, "
1757 "readout=%08x, refetch=%08x)",
1758 prev
, commit
, readout
, refetch
);
1762 trace_debug ("GDBserver has touched the trace buffer, not effective."
1763 " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1764 prev
, commit
, readout
, refetch
);
1770 /* We have a new piece of the trace buffer. Hurray! */
1772 /* Add an EOB marker just past this allocation. */
1773 ((struct traceframe
*) tbctrl
->free
)->tpnum
= 0;
1774 ((struct traceframe
*) tbctrl
->free
)->data_size
= 0;
1776 /* Adjust the request back down, now that we know we have space for
1778 amt
-= sizeof (struct traceframe
);
1782 trace_debug ("Allocated %d bytes", (int) amt
);
1783 trace_debug ("Trace buffer [%d] start=%d free=%d "
1784 "endfree=%d wrap=%d hi=%d",
1786 (int) (tbctrl
->start
- trace_buffer_lo
),
1787 (int) (tbctrl
->free
- trace_buffer_lo
),
1788 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1789 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1790 (int) (trace_buffer_hi
- trace_buffer_lo
));
1796 #ifndef IN_PROCESS_AGENT
1798 /* Return the total free space. This is not necessarily the largest
1799 block we can allocate, because of the two-part case. */
1804 if (trace_buffer_free
<= trace_buffer_end_free
)
1805 return trace_buffer_end_free
- trace_buffer_free
;
1807 return ((trace_buffer_end_free
- trace_buffer_lo
)
1808 + (trace_buffer_hi
- trace_buffer_free
));
1811 /* An 'S' in continuation packets indicates remainder are for
1814 static int seen_step_action_flag
;
1816 /* Create a tracepoint (location) with given number and address. Add this
1817 new tracepoint to list and sort this list. */
1819 static struct tracepoint
*
1820 add_tracepoint (int num
, CORE_ADDR addr
)
1822 struct tracepoint
*tpoint
, **tp_next
;
1824 tpoint
= xmalloc (sizeof (struct tracepoint
));
1825 tpoint
->number
= num
;
1826 tpoint
->address
= addr
;
1827 tpoint
->numactions
= 0;
1828 tpoint
->actions
= NULL
;
1829 tpoint
->actions_str
= NULL
;
1830 tpoint
->cond
= NULL
;
1831 tpoint
->num_step_actions
= 0;
1832 tpoint
->step_actions
= NULL
;
1833 tpoint
->step_actions_str
= NULL
;
1834 /* Start all off as regular (slow) tracepoints. */
1835 tpoint
->type
= trap_tracepoint
;
1836 tpoint
->orig_size
= -1;
1837 tpoint
->source_strings
= NULL
;
1838 tpoint
->compiled_cond
= 0;
1839 tpoint
->handle
= NULL
;
1840 tpoint
->next
= NULL
;
1842 /* Find a place to insert this tracepoint into list in order to keep
1843 the tracepoint list still in the ascending order. There may be
1844 multiple tracepoints at the same address as TPOINT's, and this
1845 guarantees TPOINT is inserted after all the tracepoints which are
1846 set at the same address. For example, fast tracepoints A, B, C are
1847 set at the same address, and D is to be insert at the same place as
1850 -->| A |--> | B |-->| C |->...
1852 One jump pad was created for tracepoint A, B, and C, and the target
1853 address of A is referenced/used in jump pad. So jump pad will let
1854 inferior jump to A. If D is inserted in front of A, like this,
1856 -->| D |-->| A |--> | B |-->| C |->...
1858 without updating jump pad, D is not reachable during collect, which
1859 is wrong. As we can see, the order of B, C and D doesn't matter, but
1860 A should always be the `first' one. */
1861 for (tp_next
= &tracepoints
;
1862 (*tp_next
) != NULL
&& (*tp_next
)->address
<= tpoint
->address
;
1863 tp_next
= &(*tp_next
)->next
)
1865 tpoint
->next
= *tp_next
;
1867 last_tracepoint
= tpoint
;
1869 seen_step_action_flag
= 0;
1874 #ifndef IN_PROCESS_AGENT
1876 /* Return the tracepoint with the given number and address, or NULL. */
1878 static struct tracepoint
*
1879 find_tracepoint (int id
, CORE_ADDR addr
)
1881 struct tracepoint
*tpoint
;
1883 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
1884 if (tpoint
->number
== id
&& tpoint
->address
== addr
)
1890 /* Remove TPOINT from global list. */
1893 remove_tracepoint (struct tracepoint
*tpoint
)
1895 struct tracepoint
*tp
, *tp_prev
;
1897 for (tp
= tracepoints
, tp_prev
= NULL
; tp
&& tp
!= tpoint
;
1898 tp_prev
= tp
, tp
= tp
->next
)
1904 tp_prev
->next
= tp
->next
;
1906 tracepoints
= tp
->next
;
1912 /* There may be several tracepoints with the same number (because they
1913 are "locations", in GDB parlance); return the next one after the
1914 given tracepoint, or search from the beginning of the list if the
1915 first argument is NULL. */
1917 static struct tracepoint
*
1918 find_next_tracepoint_by_number (struct tracepoint
*prev_tp
, int num
)
1920 struct tracepoint
*tpoint
;
1923 tpoint
= prev_tp
->next
;
1925 tpoint
= tracepoints
;
1926 for (; tpoint
; tpoint
= tpoint
->next
)
1927 if (tpoint
->number
== num
)
1935 /* Append another action to perform when the tracepoint triggers. */
1938 add_tracepoint_action (struct tracepoint
*tpoint
, char *packet
)
1944 seen_step_action_flag
= 1;
1952 char *act_start
= act
;
1953 struct tracepoint_action
*action
= NULL
;
1959 struct collect_memory_action
*maction
;
1963 maction
= xmalloc (sizeof *maction
);
1964 maction
->base
.type
= *act
;
1965 maction
->base
.ops
= &m_tracepoint_action_ops
;
1966 action
= &maction
->base
;
1969 is_neg
= (*act
== '-');
1972 act
= unpack_varlen_hex (act
, &basereg
);
1974 act
= unpack_varlen_hex (act
, &maction
->addr
);
1976 act
= unpack_varlen_hex (act
, &maction
->len
);
1977 maction
->basereg
= (is_neg
1980 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
1981 pulongest (maction
->len
),
1982 paddress (maction
->addr
), maction
->basereg
);
1987 struct collect_registers_action
*raction
;
1989 raction
= xmalloc (sizeof *raction
);
1990 raction
->base
.type
= *act
;
1991 raction
->base
.ops
= &r_tracepoint_action_ops
;
1992 action
= &raction
->base
;
1994 trace_debug ("Want to collect registers");
1996 /* skip past hex digits of mask for now */
1997 while (isxdigit(*act
))
2003 struct collect_static_trace_data_action
*raction
;
2005 raction
= xmalloc (sizeof *raction
);
2006 raction
->base
.type
= *act
;
2007 raction
->base
.ops
= &l_tracepoint_action_ops
;
2008 action
= &raction
->base
;
2010 trace_debug ("Want to collect static trace data");
2015 trace_debug ("Unexpected step action, ignoring");
2020 struct eval_expr_action
*xaction
;
2022 xaction
= xmalloc (sizeof (*xaction
));
2023 xaction
->base
.type
= *act
;
2024 xaction
->base
.ops
= &x_tracepoint_action_ops
;
2025 action
= &xaction
->base
;
2027 trace_debug ("Want to evaluate expression");
2028 xaction
->expr
= gdb_parse_agent_expr (&act
);
2032 trace_debug ("unknown trace action '%c', ignoring...", *act
);
2041 if (seen_step_action_flag
)
2043 tpoint
->num_step_actions
++;
2045 tpoint
->step_actions
2046 = xrealloc (tpoint
->step_actions
,
2047 (sizeof (*tpoint
->step_actions
)
2048 * tpoint
->num_step_actions
));
2049 tpoint
->step_actions_str
2050 = xrealloc (tpoint
->step_actions_str
,
2051 (sizeof (*tpoint
->step_actions_str
)
2052 * tpoint
->num_step_actions
));
2053 tpoint
->step_actions
[tpoint
->num_step_actions
- 1] = action
;
2054 tpoint
->step_actions_str
[tpoint
->num_step_actions
- 1]
2055 = savestring (act_start
, act
- act_start
);
2059 tpoint
->numactions
++;
2061 = xrealloc (tpoint
->actions
,
2062 sizeof (*tpoint
->actions
) * tpoint
->numactions
);
2064 = xrealloc (tpoint
->actions_str
,
2065 sizeof (*tpoint
->actions_str
) * tpoint
->numactions
);
2066 tpoint
->actions
[tpoint
->numactions
- 1] = action
;
2067 tpoint
->actions_str
[tpoint
->numactions
- 1]
2068 = savestring (act_start
, act
- act_start
);
2075 /* Find or create a trace state variable with the given number. */
2077 static struct trace_state_variable
*
2078 get_trace_state_variable (int num
)
2080 struct trace_state_variable
*tsv
;
2082 #ifdef IN_PROCESS_AGENT
2083 /* Search for an existing variable. */
2084 for (tsv
= alloced_trace_state_variables
; tsv
; tsv
= tsv
->next
)
2085 if (tsv
->number
== num
)
2089 /* Search for an existing variable. */
2090 for (tsv
= trace_state_variables
; tsv
; tsv
= tsv
->next
)
2091 if (tsv
->number
== num
)
2097 /* Find or create a trace state variable with the given number. */
2099 static struct trace_state_variable
*
2100 create_trace_state_variable (int num
, int gdb
)
2102 struct trace_state_variable
*tsv
;
2104 tsv
= get_trace_state_variable (num
);
2108 /* Create a new variable. */
2109 tsv
= xmalloc (sizeof (struct trace_state_variable
));
2111 tsv
->initial_value
= 0;
2115 #ifdef IN_PROCESS_AGENT
2118 tsv
->next
= alloced_trace_state_variables
;
2119 alloced_trace_state_variables
= tsv
;
2124 tsv
->next
= trace_state_variables
;
2125 trace_state_variables
= tsv
;
2130 IP_AGENT_EXPORT LONGEST
2131 get_trace_state_variable_value (int num
)
2133 struct trace_state_variable
*tsv
;
2135 tsv
= get_trace_state_variable (num
);
2139 trace_debug ("No trace state variable %d, skipping value get", num
);
2143 /* Call a getter function if we have one. While it's tempting to
2144 set up something to only call the getter once per tracepoint hit,
2145 it could run afoul of thread races. Better to let the getter
2146 handle it directly, if necessary to worry about it. */
2148 tsv
->value
= (tsv
->getter
) ();
2150 trace_debug ("get_trace_state_variable_value(%d) ==> %s",
2151 num
, plongest (tsv
->value
));
2156 IP_AGENT_EXPORT
void
2157 set_trace_state_variable_value (int num
, LONGEST val
)
2159 struct trace_state_variable
*tsv
;
2161 tsv
= get_trace_state_variable (num
);
2165 trace_debug ("No trace state variable %d, skipping value set", num
);
2173 agent_get_trace_state_variable_value (int num
)
2175 return get_trace_state_variable_value (num
);
2179 agent_set_trace_state_variable_value (int num
, LONGEST val
)
2181 set_trace_state_variable_value (num
, val
);
2185 set_trace_state_variable_name (int num
, const char *name
)
2187 struct trace_state_variable
*tsv
;
2189 tsv
= get_trace_state_variable (num
);
2193 trace_debug ("No trace state variable %d, skipping name set", num
);
2197 tsv
->name
= (char *) name
;
2201 set_trace_state_variable_getter (int num
, LONGEST (*getter
) (void))
2203 struct trace_state_variable
*tsv
;
2205 tsv
= get_trace_state_variable (num
);
2209 trace_debug ("No trace state variable %d, skipping getter set", num
);
2213 tsv
->getter
= getter
;
2216 /* Add a raw traceframe for the given tracepoint. */
2218 static struct traceframe
*
2219 add_traceframe (struct tracepoint
*tpoint
)
2221 struct traceframe
*tframe
;
2223 tframe
= trace_buffer_alloc (sizeof (struct traceframe
));
2228 tframe
->tpnum
= tpoint
->number
;
2229 tframe
->data_size
= 0;
2234 /* Add a block to the traceframe currently being worked on. */
2236 static unsigned char *
2237 add_traceframe_block (struct traceframe
*tframe
,
2238 struct tracepoint
*tpoint
, int amt
)
2240 unsigned char *block
;
2245 block
= trace_buffer_alloc (amt
);
2250 gdb_assert (tframe
->tpnum
== tpoint
->number
);
2252 tframe
->data_size
+= amt
;
2253 tpoint
->traceframe_usage
+= amt
;
2258 /* Flag that the current traceframe is finished. */
2261 finish_traceframe (struct traceframe
*tframe
)
2263 ++traceframe_write_count
;
2264 ++traceframes_created
;
2267 #ifndef IN_PROCESS_AGENT
2269 /* Given a traceframe number NUM, find the NUMth traceframe in the
2272 static struct traceframe
*
2273 find_traceframe (int num
)
2275 struct traceframe
*tframe
;
2278 for (tframe
= FIRST_TRACEFRAME ();
2280 tframe
= NEXT_TRACEFRAME (tframe
))
2291 get_traceframe_address (struct traceframe
*tframe
)
2294 struct tracepoint
*tpoint
;
2296 addr
= traceframe_get_pc (tframe
);
2301 /* Fallback strategy, will be incorrect for while-stepping frames
2302 and multi-location tracepoints. */
2303 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
2304 return tpoint
->address
;
2307 /* Search for the next traceframe whose address is inside or outside
2310 static struct traceframe
*
2311 find_next_traceframe_in_range (CORE_ADDR lo
, CORE_ADDR hi
, int inside_p
,
2314 struct traceframe
*tframe
;
2317 *tfnump
= current_traceframe
+ 1;
2318 tframe
= find_traceframe (*tfnump
);
2319 /* The search is not supposed to wrap around. */
2326 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2328 tfaddr
= get_traceframe_address (tframe
);
2330 ? (lo
<= tfaddr
&& tfaddr
<= hi
)
2331 : (lo
> tfaddr
|| tfaddr
> hi
))
2340 /* Search for the next traceframe recorded by the given tracepoint.
2341 Note that for multi-location tracepoints, this will find whatever
2342 location appears first. */
2344 static struct traceframe
*
2345 find_next_traceframe_by_tracepoint (int num
, int *tfnump
)
2347 struct traceframe
*tframe
;
2349 *tfnump
= current_traceframe
+ 1;
2350 tframe
= find_traceframe (*tfnump
);
2351 /* The search is not supposed to wrap around. */
2358 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2360 if (tframe
->tpnum
== num
)
2371 #ifndef IN_PROCESS_AGENT
2373 /* Clear all past trace state. */
2376 cmd_qtinit (char *packet
)
2378 struct trace_state_variable
*tsv
, *prev
, *next
;
2380 /* Make sure we don't try to read from a trace frame. */
2381 current_traceframe
= -1;
2385 trace_debug ("Initializing the trace");
2387 clear_installed_tracepoints ();
2388 clear_readonly_regions ();
2391 last_tracepoint
= NULL
;
2393 /* Clear out any leftover trace state variables. Ones with target
2394 defined getters should be kept however. */
2396 tsv
= trace_state_variables
;
2399 trace_debug ("Looking at var %d", tsv
->number
);
2400 if (tsv
->getter
== NULL
)
2406 trace_state_variables
= next
;
2407 trace_debug ("Deleting var %d", tsv
->number
);
2418 clear_trace_buffer ();
2419 clear_inferior_trace_buffer ();
2424 /* Unprobe the UST marker at ADDRESS. */
2427 unprobe_marker_at (CORE_ADDR address
)
2429 char cmd
[IPA_CMD_BUF_SIZE
];
2431 sprintf (cmd
, "unprobe_marker_at:%s", paddress (address
));
2432 run_inferior_command (cmd
, strlen (cmd
) + 1);
2435 /* Restore the program to its pre-tracing state. This routine may be called
2436 in error situations, so it needs to be careful about only restoring
2437 from known-valid bits. */
2440 clear_installed_tracepoints (void)
2442 struct tracepoint
*tpoint
;
2443 struct tracepoint
*prev_stpoint
;
2446 cancel_breakpoints ();
2448 prev_stpoint
= NULL
;
2450 /* Restore any bytes overwritten by tracepoints. */
2451 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
2453 /* Catch the case where we might try to remove a tracepoint that
2454 was never actually installed. */
2455 if (tpoint
->handle
== NULL
)
2457 trace_debug ("Tracepoint %d at 0x%s was "
2458 "never installed, nothing to clear",
2459 tpoint
->number
, paddress (tpoint
->address
));
2463 switch (tpoint
->type
)
2465 case trap_tracepoint
:
2466 delete_breakpoint (tpoint
->handle
);
2468 case fast_tracepoint
:
2469 delete_fast_tracepoint_jump (tpoint
->handle
);
2471 case static_tracepoint
:
2472 if (prev_stpoint
!= NULL
2473 && prev_stpoint
->address
== tpoint
->address
)
2474 /* Nothing to do. We already unprobed a tracepoint set at
2475 this marker address (and there can only be one probe
2480 unprobe_marker_at (tpoint
->address
);
2481 prev_stpoint
= tpoint
;
2486 tpoint
->handle
= NULL
;
2492 /* Parse a packet that defines a tracepoint. */
2495 cmd_qtdp (char *own_buf
)
2498 /* Whether there is a trailing hyphen at the end of the QTDP packet. */
2499 int trail_hyphen
= 0;
2503 struct tracepoint
*tpoint
;
2505 char *packet
= own_buf
;
2507 packet
+= strlen ("QTDP:");
2509 /* A hyphen at the beginning marks a packet specifying actions for a
2510 tracepoint already supplied. */
2517 packet
= unpack_varlen_hex (packet
, &num
);
2518 ++packet
; /* skip a colon */
2519 packet
= unpack_varlen_hex (packet
, &addr
);
2520 ++packet
; /* skip a colon */
2522 /* See if we already have this tracepoint. */
2523 tpoint
= find_tracepoint (num
, addr
);
2527 /* Duplicate tracepoints are never allowed. */
2530 trace_debug ("Tracepoint error: tracepoint %d"
2531 " at 0x%s already exists",
2532 (int) num
, paddress (addr
));
2533 write_enn (own_buf
);
2537 tpoint
= add_tracepoint (num
, addr
);
2539 tpoint
->enabled
= (*packet
== 'E');
2540 ++packet
; /* skip 'E' */
2541 ++packet
; /* skip a colon */
2542 packet
= unpack_varlen_hex (packet
, &count
);
2543 tpoint
->step_count
= count
;
2544 ++packet
; /* skip a colon */
2545 packet
= unpack_varlen_hex (packet
, &count
);
2546 tpoint
->pass_count
= count
;
2547 /* See if we have any of the additional optional fields. */
2548 while (*packet
== ':')
2553 tpoint
->type
= fast_tracepoint
;
2555 packet
= unpack_varlen_hex (packet
, &count
);
2556 tpoint
->orig_size
= count
;
2558 else if (*packet
== 'S')
2560 tpoint
->type
= static_tracepoint
;
2563 else if (*packet
== 'X')
2565 actparm
= (char *) packet
;
2566 tpoint
->cond
= gdb_parse_agent_expr (&actparm
);
2569 else if (*packet
== '-')
2571 else if (*packet
== '\0')
2574 trace_debug ("Unknown optional tracepoint field");
2579 trace_debug ("Also has actions\n");
2582 trace_debug ("Defined %stracepoint %d at 0x%s, "
2583 "enabled %d step %" PRIu64
" pass %" PRIu64
,
2584 tpoint
->type
== fast_tracepoint
? "fast "
2585 : tpoint
->type
== static_tracepoint
? "static " : "",
2586 tpoint
->number
, paddress (tpoint
->address
), tpoint
->enabled
,
2587 tpoint
->step_count
, tpoint
->pass_count
);
2590 add_tracepoint_action (tpoint
, packet
);
2593 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2594 (int) num
, paddress (addr
));
2595 write_enn (own_buf
);
2599 /* Install tracepoint during tracing only once for each tracepoint location.
2600 For each tracepoint loc, GDB may send multiple QTDP packets, and we can
2601 determine the last QTDP packet for one tracepoint location by checking
2602 trailing hyphen in QTDP packet. */
2603 if (tracing
&& !trail_hyphen
)
2605 struct tracepoint
*tp
= NULL
;
2607 /* Pause all threads temporarily while we patch tracepoints. */
2610 /* download_tracepoint will update global `tracepoints'
2611 list, so it is unsafe to leave threads in jump pad. */
2612 stabilize_threads ();
2614 /* Freeze threads. */
2618 if (tpoint
->type
!= trap_tracepoint
)
2620 /* Find another fast or static tracepoint at the same address. */
2621 for (tp
= tracepoints
; tp
; tp
= tp
->next
)
2623 if (tp
->address
== tpoint
->address
&& tp
->type
== tpoint
->type
2624 && tp
->number
!= tpoint
->number
)
2628 /* TPOINT is installed at the same address as TP. */
2631 if (tpoint
->type
== fast_tracepoint
)
2632 clone_fast_tracepoint (tpoint
, tp
);
2633 else if (tpoint
->type
== static_tracepoint
)
2634 tpoint
->handle
= (void *) -1;
2638 if (use_agent
&& tpoint
->type
== fast_tracepoint
2639 && agent_capability_check (AGENT_CAPA_FAST_TRACE
))
2641 /* Download and install fast tracepoint by agent. */
2642 if (tracepoint_send_agent (tpoint
) == 0)
2646 write_enn (own_buf
);
2647 remove_tracepoint (tpoint
);
2652 download_tracepoint (tpoint
);
2654 if (tpoint
->type
== trap_tracepoint
|| tp
== NULL
)
2656 install_tracepoint (tpoint
, own_buf
);
2657 if (strcmp (own_buf
, "OK") != 0)
2658 remove_tracepoint (tpoint
);
2672 cmd_qtdpsrc (char *own_buf
)
2674 ULONGEST num
, addr
, start
, slen
;
2675 struct tracepoint
*tpoint
;
2676 char *packet
= own_buf
;
2677 char *saved
, *srctype
, *src
;
2679 struct source_string
*last
, *newlast
;
2681 packet
+= strlen ("QTDPsrc:");
2683 packet
= unpack_varlen_hex (packet
, &num
);
2684 ++packet
; /* skip a colon */
2685 packet
= unpack_varlen_hex (packet
, &addr
);
2686 ++packet
; /* skip a colon */
2688 /* See if we already have this tracepoint. */
2689 tpoint
= find_tracepoint (num
, addr
);
2693 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2694 (int) num
, paddress (addr
));
2695 write_enn (own_buf
);
2700 packet
= strchr (packet
, ':');
2701 srctype
= xmalloc (packet
- saved
+ 1);
2702 memcpy (srctype
, saved
, packet
- saved
);
2703 srctype
[packet
- saved
] = '\0';
2705 packet
= unpack_varlen_hex (packet
, &start
);
2706 ++packet
; /* skip a colon */
2707 packet
= unpack_varlen_hex (packet
, &slen
);
2708 ++packet
; /* skip a colon */
2709 src
= xmalloc (slen
+ 1);
2710 nbytes
= unhexify (src
, packet
, strlen (packet
) / 2);
2713 newlast
= xmalloc (sizeof (struct source_string
));
2714 newlast
->type
= srctype
;
2716 newlast
->next
= NULL
;
2717 /* Always add a source string to the end of the list;
2718 this keeps sequences of actions/commands in the right
2720 if (tpoint
->source_strings
)
2722 for (last
= tpoint
->source_strings
; last
->next
; last
= last
->next
)
2724 last
->next
= newlast
;
2727 tpoint
->source_strings
= newlast
;
2733 cmd_qtdv (char *own_buf
)
2735 ULONGEST num
, val
, builtin
;
2738 struct trace_state_variable
*tsv
;
2739 char *packet
= own_buf
;
2741 packet
+= strlen ("QTDV:");
2743 packet
= unpack_varlen_hex (packet
, &num
);
2744 ++packet
; /* skip a colon */
2745 packet
= unpack_varlen_hex (packet
, &val
);
2746 ++packet
; /* skip a colon */
2747 packet
= unpack_varlen_hex (packet
, &builtin
);
2748 ++packet
; /* skip a colon */
2750 nbytes
= strlen (packet
) / 2;
2751 varname
= xmalloc (nbytes
+ 1);
2752 nbytes
= unhexify (varname
, packet
, nbytes
);
2753 varname
[nbytes
] = '\0';
2755 tsv
= create_trace_state_variable (num
, 1);
2756 tsv
->initial_value
= (LONGEST
) val
;
2757 tsv
->name
= varname
;
2759 set_trace_state_variable_value (num
, (LONGEST
) val
);
2765 cmd_qtenable_disable (char *own_buf
, int enable
)
2767 char *packet
= own_buf
;
2769 struct tracepoint
*tp
;
2771 packet
+= strlen (enable
? "QTEnable:" : "QTDisable:");
2772 packet
= unpack_varlen_hex (packet
, &num
);
2773 ++packet
; /* skip a colon */
2774 packet
= unpack_varlen_hex (packet
, &addr
);
2776 tp
= find_tracepoint (num
, addr
);
2780 if ((enable
&& tp
->enabled
) || (!enable
&& !tp
->enabled
))
2782 trace_debug ("Tracepoint %d at 0x%s is already %s",
2783 (int) num
, paddress (addr
),
2784 enable
? "enabled" : "disabled");
2789 trace_debug ("%s tracepoint %d at 0x%s",
2790 enable
? "Enabling" : "Disabling",
2791 (int) num
, paddress (addr
));
2793 tp
->enabled
= enable
;
2795 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
2798 int offset
= offsetof (struct tracepoint
, enabled
);
2799 CORE_ADDR obj_addr
= tp
->obj_addr_on_target
+ offset
;
2801 ret
= prepare_to_access_memory ();
2804 trace_debug ("Failed to temporarily stop inferior threads");
2805 write_enn (own_buf
);
2809 ret
= write_inferior_integer (obj_addr
, enable
);
2810 done_accessing_memory ();
2814 trace_debug ("Cannot write enabled flag into "
2815 "inferior process memory");
2816 write_enn (own_buf
);
2825 trace_debug ("Tracepoint %d at 0x%s not found",
2826 (int) num
, paddress (addr
));
2827 write_enn (own_buf
);
2832 cmd_qtv (char *own_buf
)
2837 char *packet
= own_buf
;
2839 packet
+= strlen ("qTV:");
2840 unpack_varlen_hex (packet
, &num
);
2842 if (current_traceframe
>= 0)
2844 err
= traceframe_read_tsv ((int) num
, &val
);
2847 strcpy (own_buf
, "U");
2851 /* Only make tsv's be undefined before the first trace run. After a
2852 trace run is over, the user might want to see the last value of
2853 the tsv, and it might not be available in a traceframe. */
2854 else if (!tracing
&& strcmp (tracing_stop_reason
, "tnotrun") == 0)
2856 strcpy (own_buf
, "U");
2860 val
= get_trace_state_variable_value (num
);
2862 sprintf (own_buf
, "V%s", phex_nz (val
, 0));
2865 /* Clear out the list of readonly regions. */
2868 clear_readonly_regions (void)
2870 struct readonly_region
*roreg
;
2872 while (readonly_regions
)
2874 roreg
= readonly_regions
;
2875 readonly_regions
= readonly_regions
->next
;
2880 /* Parse the collection of address ranges whose contents GDB believes
2881 to be unchanging and so can be read directly from target memory
2882 even while looking at a traceframe. */
2885 cmd_qtro (char *own_buf
)
2887 ULONGEST start
, end
;
2888 struct readonly_region
*roreg
;
2889 char *packet
= own_buf
;
2891 trace_debug ("Want to mark readonly regions");
2893 clear_readonly_regions ();
2895 packet
+= strlen ("QTro");
2897 while (*packet
== ':')
2899 ++packet
; /* skip a colon */
2900 packet
= unpack_varlen_hex (packet
, &start
);
2901 ++packet
; /* skip a comma */
2902 packet
= unpack_varlen_hex (packet
, &end
);
2903 roreg
= xmalloc (sizeof (struct readonly_region
));
2904 roreg
->start
= start
;
2906 roreg
->next
= readonly_regions
;
2907 readonly_regions
= roreg
;
2908 trace_debug ("Added readonly region from 0x%s to 0x%s",
2909 paddress (roreg
->start
), paddress (roreg
->end
));
2915 /* Test to see if the given range is in our list of readonly ranges.
2916 We only test for being entirely within a range, GDB is not going to
2917 send a single memory packet that spans multiple regions. */
2920 in_readonly_region (CORE_ADDR addr
, ULONGEST length
)
2922 struct readonly_region
*roreg
;
2924 for (roreg
= readonly_regions
; roreg
; roreg
= roreg
->next
)
2925 if (roreg
->start
<= addr
&& (addr
+ length
- 1) <= roreg
->end
)
2931 /* The maximum size of a jump pad entry. */
2932 static const int max_jump_pad_size
= 0x100;
2934 static CORE_ADDR gdb_jump_pad_head
;
2936 /* Return the address of the next free jump space. */
2939 get_jump_space_head (void)
2941 if (gdb_jump_pad_head
== 0)
2943 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
2944 &gdb_jump_pad_head
))
2945 fatal ("error extracting jump_pad_buffer");
2948 return gdb_jump_pad_head
;
2951 /* Reserve USED bytes from the jump space. */
2954 claim_jump_space (ULONGEST used
)
2956 trace_debug ("claim_jump_space reserves %s bytes at %s",
2957 pulongest (used
), paddress (gdb_jump_pad_head
));
2958 gdb_jump_pad_head
+= used
;
2961 static CORE_ADDR trampoline_buffer_head
= 0;
2962 static CORE_ADDR trampoline_buffer_tail
;
2964 /* Reserve USED bytes from the trampoline buffer and return the
2965 address of the start of the reserved space in TRAMPOLINE. Returns
2966 non-zero if the space is successfully claimed. */
2969 claim_trampoline_space (ULONGEST used
, CORE_ADDR
*trampoline
)
2971 if (!trampoline_buffer_head
)
2973 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
2974 &trampoline_buffer_tail
))
2976 fatal ("error extracting trampoline_buffer");
2980 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
2981 &trampoline_buffer_head
))
2983 fatal ("error extracting trampoline_buffer_end");
2988 /* Start claiming space from the top of the trampoline space. If
2989 the space is located at the bottom of the virtual address space,
2990 this reduces the possibility that corruption will occur if a null
2991 pointer is used to write to memory. */
2992 if (trampoline_buffer_head
- trampoline_buffer_tail
< used
)
2994 trace_debug ("claim_trampoline_space failed to reserve %s bytes",
2999 trampoline_buffer_head
-= used
;
3001 trace_debug ("claim_trampoline_space reserves %s bytes at %s",
3002 pulongest (used
), paddress (trampoline_buffer_head
));
3004 *trampoline
= trampoline_buffer_head
;
3008 /* Returns non-zero if there is space allocated for use in trampolines
3009 for fast tracepoints. */
3012 have_fast_tracepoint_trampoline_buffer (char *buf
)
3014 CORE_ADDR trampoline_end
, errbuf
;
3016 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
3019 fatal ("error extracting trampoline_buffer_end");
3026 strcpy (buf
, "was claiming");
3027 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_error
,
3030 fatal ("error extracting errbuf");
3034 read_inferior_memory (errbuf
, (unsigned char *) buf
, 100);
3037 return trampoline_end
!= 0;
3040 /* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
3041 the command fails, or 0 otherwise. If the command ran
3042 successfully, but probing the marker failed, ERROUT will be filled
3043 with the error to reply to GDB, and -1 is also returned. This
3044 allows directly passing IPA errors to GDB. */
3047 probe_marker_at (CORE_ADDR address
, char *errout
)
3049 char cmd
[IPA_CMD_BUF_SIZE
];
3052 sprintf (cmd
, "probe_marker_at:%s", paddress (address
));
3053 err
= run_inferior_command (cmd
, strlen (cmd
) + 1);
3059 strcpy (errout
, cmd
);
3068 clone_fast_tracepoint (struct tracepoint
*to
, const struct tracepoint
*from
)
3070 to
->jump_pad
= from
->jump_pad
;
3071 to
->jump_pad_end
= from
->jump_pad_end
;
3072 to
->trampoline
= from
->trampoline
;
3073 to
->trampoline_end
= from
->trampoline_end
;
3074 to
->adjusted_insn_addr
= from
->adjusted_insn_addr
;
3075 to
->adjusted_insn_addr_end
= from
->adjusted_insn_addr_end
;
3076 to
->handle
= from
->handle
;
3078 gdb_assert (from
->handle
);
3079 inc_ref_fast_tracepoint_jump ((struct fast_tracepoint_jump
*) from
->handle
);
3082 #define MAX_JUMP_SIZE 20
3084 /* Install fast tracepoint. Return 0 if successful, otherwise return
3088 install_fast_tracepoint (struct tracepoint
*tpoint
, char *errbuf
)
3090 CORE_ADDR jentry
, jump_entry
;
3091 CORE_ADDR trampoline
;
3092 ULONGEST trampoline_size
;
3094 /* The jump to the jump pad of the last fast tracepoint
3096 unsigned char fjump
[MAX_JUMP_SIZE
];
3097 ULONGEST fjump_size
;
3099 if (tpoint
->orig_size
< target_get_min_fast_tracepoint_insn_len ())
3101 trace_debug ("Requested a fast tracepoint on an instruction "
3102 "that is of less than the minimum length.");
3106 jentry
= jump_entry
= get_jump_space_head ();
3109 trampoline_size
= 0;
3111 /* Install the jump pad. */
3112 err
= install_fast_tracepoint_jump_pad (tpoint
->obj_addr_on_target
,
3114 ipa_sym_addrs
.addr_gdb_collect
,
3115 ipa_sym_addrs
.addr_collecting
,
3118 &trampoline
, &trampoline_size
,
3120 &tpoint
->adjusted_insn_addr
,
3121 &tpoint
->adjusted_insn_addr_end
,
3128 tpoint
->handle
= set_fast_tracepoint_jump (tpoint
->address
, fjump
,
3131 if (tpoint
->handle
!= NULL
)
3133 tpoint
->jump_pad
= jump_entry
;
3134 tpoint
->jump_pad_end
= jentry
;
3135 tpoint
->trampoline
= trampoline
;
3136 tpoint
->trampoline_end
= trampoline
+ trampoline_size
;
3138 /* Pad to 8-byte alignment. */
3139 jentry
= ((jentry
+ 7) & ~0x7);
3140 claim_jump_space (jentry
- jump_entry
);
3147 /* Install tracepoint TPOINT, and write reply message in OWN_BUF. */
3150 install_tracepoint (struct tracepoint
*tpoint
, char *own_buf
)
3152 tpoint
->handle
= NULL
;
3155 if (tpoint
->type
== trap_tracepoint
)
3157 /* Tracepoints are installed as memory breakpoints. Just go
3158 ahead and install the trap. The breakpoints module
3159 handles duplicated breakpoints, and the memory read
3160 routine handles un-patching traps from memory reads. */
3161 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3162 tracepoint_handler
);
3164 else if (tpoint
->type
== fast_tracepoint
|| tpoint
->type
== static_tracepoint
)
3166 if (!agent_loaded_p ())
3168 trace_debug ("Requested a %s tracepoint, but fast "
3169 "tracepoints aren't supported.",
3170 tpoint
->type
== static_tracepoint
? "static" : "fast");
3171 write_e_ipa_not_loaded (own_buf
);
3174 if (tpoint
->type
== static_tracepoint
3175 && !in_process_agent_supports_ust ())
3177 trace_debug ("Requested a static tracepoint, but static "
3178 "tracepoints are not supported.");
3179 write_e_ust_not_loaded (own_buf
);
3183 if (tpoint
->type
== fast_tracepoint
)
3184 install_fast_tracepoint (tpoint
, own_buf
);
3187 if (probe_marker_at (tpoint
->address
, own_buf
) == 0)
3188 tpoint
->handle
= (void *) -1;
3193 internal_error (__FILE__
, __LINE__
, "Unknown tracepoint type");
3195 if (tpoint
->handle
== NULL
)
3197 if (*own_buf
== '\0')
3198 write_enn (own_buf
);
3204 static void download_tracepoint_1 (struct tracepoint
*tpoint
);
3207 cmd_qtstart (char *packet
)
3209 struct tracepoint
*tpoint
, *prev_ftpoint
, *prev_stpoint
;
3210 CORE_ADDR tpptr
= 0, prev_tpptr
= 0;
3212 trace_debug ("Starting the trace");
3214 /* Pause all threads temporarily while we patch tracepoints. */
3217 /* Get threads out of jump pads. Safe to do here, since this is a
3218 top level command. And, required to do here, since we're
3219 deleting/rewriting jump pads. */
3221 stabilize_threads ();
3223 /* Freeze threads. */
3226 /* Sync the fast tracepoints list in the inferior ftlib. */
3227 if (agent_loaded_p ())
3228 download_trace_state_variables ();
3230 /* No previous fast tpoint yet. */
3231 prev_ftpoint
= NULL
;
3233 /* No previous static tpoint yet. */
3234 prev_stpoint
= NULL
;
3238 /* Start out empty. */
3239 if (agent_loaded_p ())
3240 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, 0);
3242 /* Download and install tracepoints. */
3243 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
3245 /* Ensure all the hit counts start at zero. */
3246 tpoint
->hit_count
= 0;
3247 tpoint
->traceframe_usage
= 0;
3249 if (tpoint
->type
== trap_tracepoint
)
3251 /* Tracepoints are installed as memory breakpoints. Just go
3252 ahead and install the trap. The breakpoints module
3253 handles duplicated breakpoints, and the memory read
3254 routine handles un-patching traps from memory reads. */
3255 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3256 tracepoint_handler
);
3258 else if (tpoint
->type
== fast_tracepoint
3259 || tpoint
->type
== static_tracepoint
)
3261 if (maybe_write_ipa_not_loaded (packet
))
3263 trace_debug ("Requested a %s tracepoint, but fast "
3264 "tracepoints aren't supported.",
3265 tpoint
->type
== static_tracepoint
3266 ? "static" : "fast");
3270 if (tpoint
->type
== fast_tracepoint
)
3273 = use_agent
&& agent_capability_check (AGENT_CAPA_FAST_TRACE
);
3275 if (prev_ftpoint
!= NULL
3276 && prev_ftpoint
->address
== tpoint
->address
)
3279 tracepoint_send_agent (tpoint
);
3281 download_tracepoint_1 (tpoint
);
3283 clone_fast_tracepoint (tpoint
, prev_ftpoint
);
3287 /* Tracepoint is installed successfully? */
3290 /* Download and install fast tracepoint by agent. */
3292 installed
= !tracepoint_send_agent (tpoint
);
3295 download_tracepoint_1 (tpoint
);
3296 installed
= !install_fast_tracepoint (tpoint
, packet
);
3300 prev_ftpoint
= tpoint
;
3305 if (!in_process_agent_supports_ust ())
3307 trace_debug ("Requested a static tracepoint, but static "
3308 "tracepoints are not supported.");
3312 download_tracepoint_1 (tpoint
);
3313 /* Can only probe a given marker once. */
3314 if (prev_stpoint
!= NULL
3315 && prev_stpoint
->address
== tpoint
->address
)
3316 tpoint
->handle
= (void *) -1;
3319 if (probe_marker_at (tpoint
->address
, packet
) == 0)
3321 tpoint
->handle
= (void *) -1;
3323 /* So that we can handle multiple static tracepoints
3324 at the same address easily. */
3325 prev_stpoint
= tpoint
;
3331 tpptr
= tpoint
->obj_addr_on_target
;
3333 if (tpoint
== tracepoints
)
3334 /* First object in list, set the head pointer in the
3336 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, tpptr
);
3338 write_inferior_data_ptr (prev_tpptr
+ offsetof (struct tracepoint
,
3343 /* Any failure in the inner loop is sufficient cause to give
3345 if (tpoint
->handle
== NULL
)
3349 /* Any error in tracepoint insertion is unacceptable; better to
3350 address the problem now, than end up with a useless or misleading
3354 clear_installed_tracepoints ();
3355 if (*packet
== '\0')
3361 stopping_tracepoint
= NULL
;
3362 trace_buffer_is_full
= 0;
3363 expr_eval_result
= expr_eval_no_error
;
3364 error_tracepoint
= NULL
;
3365 tracing_start_time
= get_timestamp ();
3367 /* Tracing is now active, hits will now start being logged. */
3370 if (agent_loaded_p ())
3372 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 1))
3373 fatal ("Error setting tracing variable in lib");
3375 if (write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
3377 fatal ("Error clearing stopping_tracepoint variable in lib");
3379 if (write_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
, 0))
3380 fatal ("Error clearing trace_buffer_is_full variable in lib");
3382 stop_tracing_bkpt
= set_breakpoint_at (ipa_sym_addrs
.addr_stop_tracing
,
3383 stop_tracing_handler
);
3384 if (stop_tracing_bkpt
== NULL
)
3385 error ("Error setting stop_tracing breakpoint");
3387 flush_trace_buffer_bkpt
3388 = set_breakpoint_at (ipa_sym_addrs
.addr_flush_trace_buffer
,
3389 flush_trace_buffer_handler
);
3390 if (flush_trace_buffer_bkpt
== NULL
)
3391 error ("Error setting flush_trace_buffer breakpoint");
3399 /* End a tracing run, filling in a stop reason to report back to GDB,
3400 and removing the tracepoints from the code. */
3407 trace_debug ("Tracing is already off, ignoring");
3411 trace_debug ("Stopping the trace");
3413 /* Pause all threads before removing fast jumps from memory,
3414 breakpoints, and touching IPA state variables (inferior memory).
3415 Some thread may hit the internal tracing breakpoints, or be
3416 collecting this moment, but that's ok, we don't release the
3417 tpoint object's memory or the jump pads here (we only do that
3418 when we're sure we can move all threads out of the jump pads).
3419 We can't now, since we may be getting here due to the inferior
3420 agent calling us. */
3422 /* Since we're removing breakpoints, cancel breakpoint hits,
3423 possibly related to the breakpoints we're about to delete. */
3424 cancel_breakpoints ();
3426 /* Stop logging. Tracepoints can still be hit, but they will not be
3429 if (agent_loaded_p ())
3431 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 0))
3432 fatal ("Error clearing tracing variable in lib");
3435 tracing_stop_time
= get_timestamp ();
3436 tracing_stop_reason
= "t???";
3437 tracing_stop_tpnum
= 0;
3438 if (stopping_tracepoint
)
3440 trace_debug ("Stopping the trace because "
3441 "tracepoint %d was hit %" PRIu64
" times",
3442 stopping_tracepoint
->number
,
3443 stopping_tracepoint
->pass_count
);
3444 tracing_stop_reason
= "tpasscount";
3445 tracing_stop_tpnum
= stopping_tracepoint
->number
;
3447 else if (trace_buffer_is_full
)
3449 trace_debug ("Stopping the trace because the trace buffer is full");
3450 tracing_stop_reason
= "tfull";
3452 else if (expr_eval_result
!= expr_eval_no_error
)
3454 trace_debug ("Stopping the trace because of an expression eval error");
3455 tracing_stop_reason
= eval_result_names
[expr_eval_result
];
3456 tracing_stop_tpnum
= error_tracepoint
->number
;
3458 #ifndef IN_PROCESS_AGENT
3459 else if (!gdb_connected ())
3461 trace_debug ("Stopping the trace because GDB disconnected");
3462 tracing_stop_reason
= "tdisconnected";
3467 trace_debug ("Stopping the trace because of a tstop command");
3468 tracing_stop_reason
= "tstop";
3471 stopping_tracepoint
= NULL
;
3472 error_tracepoint
= NULL
;
3474 /* Clear out the tracepoints. */
3475 clear_installed_tracepoints ();
3477 if (agent_loaded_p ())
3479 /* Pull in fast tracepoint trace frames from the inferior lib
3480 buffer into our buffer, even if our buffer is already full,
3481 because we want to present the full number of created frames
3482 in addition to what fit in the trace buffer. */
3483 upload_fast_traceframes ();
3486 if (stop_tracing_bkpt
!= NULL
)
3488 delete_breakpoint (stop_tracing_bkpt
);
3489 stop_tracing_bkpt
= NULL
;
3492 if (flush_trace_buffer_bkpt
!= NULL
)
3494 delete_breakpoint (flush_trace_buffer_bkpt
);
3495 flush_trace_buffer_bkpt
= NULL
;
3502 stop_tracing_handler (CORE_ADDR addr
)
3504 trace_debug ("lib hit stop_tracing");
3506 /* Don't actually handle it here. When we stop tracing we remove
3507 breakpoints from the inferior, and that is not allowed in a
3508 breakpoint handler (as the caller is walking the breakpoint
3514 flush_trace_buffer_handler (CORE_ADDR addr
)
3516 trace_debug ("lib hit flush_trace_buffer");
3521 cmd_qtstop (char *packet
)
3528 cmd_qtdisconnected (char *own_buf
)
3531 char *packet
= own_buf
;
3533 packet
+= strlen ("QTDisconnected:");
3535 unpack_varlen_hex (packet
, &setting
);
3539 disconnected_tracing
= setting
;
3543 cmd_qtframe (char *own_buf
)
3545 ULONGEST frame
, pc
, lo
, hi
, num
;
3547 struct traceframe
*tframe
;
3548 char *packet
= own_buf
;
3550 packet
+= strlen ("QTFrame:");
3552 if (strncmp (packet
, "pc:", strlen ("pc:")) == 0)
3554 packet
+= strlen ("pc:");
3555 unpack_varlen_hex (packet
, &pc
);
3556 trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc
));
3557 tframe
= find_next_traceframe_in_range (pc
, pc
, 1, &tfnum
);
3559 else if (strncmp (packet
, "range:", strlen ("range:")) == 0)
3561 packet
+= strlen ("range:");
3562 packet
= unpack_varlen_hex (packet
, &lo
);
3564 unpack_varlen_hex (packet
, &hi
);
3565 trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s",
3566 paddress (lo
), paddress (hi
));
3567 tframe
= find_next_traceframe_in_range (lo
, hi
, 1, &tfnum
);
3569 else if (strncmp (packet
, "outside:", strlen ("outside:")) == 0)
3571 packet
+= strlen ("outside:");
3572 packet
= unpack_varlen_hex (packet
, &lo
);
3574 unpack_varlen_hex (packet
, &hi
);
3575 trace_debug ("Want to find next traceframe "
3576 "outside the range 0x%s to 0x%s",
3577 paddress (lo
), paddress (hi
));
3578 tframe
= find_next_traceframe_in_range (lo
, hi
, 0, &tfnum
);
3580 else if (strncmp (packet
, "tdp:", strlen ("tdp:")) == 0)
3582 packet
+= strlen ("tdp:");
3583 unpack_varlen_hex (packet
, &num
);
3585 trace_debug ("Want to find next traceframe for tracepoint %d", tpnum
);
3586 tframe
= find_next_traceframe_by_tracepoint (tpnum
, &tfnum
);
3590 unpack_varlen_hex (packet
, &frame
);
3591 tfnum
= (int) frame
;
3594 trace_debug ("Want to stop looking at traceframes");
3595 current_traceframe
= -1;
3599 trace_debug ("Want to look at traceframe %d", tfnum
);
3600 tframe
= find_traceframe (tfnum
);
3605 current_traceframe
= tfnum
;
3606 sprintf (own_buf
, "F%xT%x", tfnum
, tframe
->tpnum
);
3609 sprintf (own_buf
, "F-1");
3613 cmd_qtstatus (char *packet
)
3615 char *stop_reason_rsp
= NULL
;
3616 char *buf1
, *buf2
, *buf3
, *str
;
3619 /* Translate the plain text of the notes back into hex for
3622 str
= (tracing_user_name
? tracing_user_name
: "");
3623 slen
= strlen (str
);
3624 buf1
= (char *) alloca (slen
* 2 + 1);
3625 hexify (buf1
, str
, slen
);
3627 str
= (tracing_notes
? tracing_notes
: "");
3628 slen
= strlen (str
);
3629 buf2
= (char *) alloca (slen
* 2 + 1);
3630 hexify (buf2
, str
, slen
);
3632 str
= (tracing_stop_note
? tracing_stop_note
: "");
3633 slen
= strlen (str
);
3634 buf3
= (char *) alloca (slen
* 2 + 1);
3635 hexify (buf3
, str
, slen
);
3637 trace_debug ("Returning trace status as %d, stop reason %s",
3638 tracing
, tracing_stop_reason
);
3640 if (agent_loaded_p ())
3644 upload_fast_traceframes ();
3649 stop_reason_rsp
= (char *) tracing_stop_reason
;
3651 /* The user visible error string in terror needs to be hex encoded.
3652 We leave it as plain string in `tracing_stop_reason' to ease
3654 if (strncmp (stop_reason_rsp
, "terror:", strlen ("terror:")) == 0)
3656 const char *result_name
;
3660 result_name
= stop_reason_rsp
+ strlen ("terror:");
3661 hexstr_len
= strlen (result_name
) * 2;
3662 p
= stop_reason_rsp
= alloca (strlen ("terror:") + hexstr_len
+ 1);
3663 strcpy (p
, "terror:");
3665 convert_int_to_ascii ((gdb_byte
*) result_name
, p
, strlen (result_name
));
3668 /* If this was a forced stop, include any stop note that was supplied. */
3669 if (strcmp (stop_reason_rsp
, "tstop") == 0)
3671 stop_reason_rsp
= alloca (strlen ("tstop:") + strlen (buf3
) + 1);
3672 strcpy (stop_reason_rsp
, "tstop:");
3673 strcat (stop_reason_rsp
, buf3
);
3679 "tframes:%x;tcreated:%x;"
3680 "tfree:%x;tsize:%s;"
3683 "starttime:%s;stoptime:%s;"
3684 "username:%s;notes:%s:",
3686 stop_reason_rsp
, tracing_stop_tpnum
,
3687 traceframe_count
, traceframes_created
,
3688 free_space (), phex_nz (trace_buffer_hi
- trace_buffer_lo
, 0),
3689 circular_trace_buffer
,
3690 disconnected_tracing
,
3691 phex_nz (tracing_start_time
, sizeof (tracing_start_time
)),
3692 phex_nz (tracing_stop_time
, sizeof (tracing_stop_time
)),
3697 cmd_qtp (char *own_buf
)
3700 struct tracepoint
*tpoint
;
3701 char *packet
= own_buf
;
3703 packet
+= strlen ("qTP:");
3705 packet
= unpack_varlen_hex (packet
, &num
);
3706 ++packet
; /* skip a colon */
3707 packet
= unpack_varlen_hex (packet
, &addr
);
3709 /* See if we already have this tracepoint. */
3710 tpoint
= find_tracepoint (num
, addr
);
3714 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
3715 (int) num
, paddress (addr
));
3716 write_enn (own_buf
);
3720 sprintf (own_buf
, "V%" PRIu64
":%" PRIu64
"", tpoint
->hit_count
,
3721 tpoint
->traceframe_usage
);
3724 /* State variables to help return all the tracepoint bits. */
3725 static struct tracepoint
*cur_tpoint
;
3726 static unsigned int cur_action
;
3727 static unsigned int cur_step_action
;
3728 static struct source_string
*cur_source_string
;
3729 static struct trace_state_variable
*cur_tsv
;
3731 /* Compose a response that is an imitation of the syntax by which the
3732 tracepoint was originally downloaded. */
3735 response_tracepoint (char *packet
, struct tracepoint
*tpoint
)
3739 sprintf (packet
, "T%x:%s:%c:%" PRIx64
":%" PRIx64
, tpoint
->number
,
3740 paddress (tpoint
->address
),
3741 (tpoint
->enabled
? 'E' : 'D'), tpoint
->step_count
,
3742 tpoint
->pass_count
);
3743 if (tpoint
->type
== fast_tracepoint
)
3744 sprintf (packet
+ strlen (packet
), ":F%x", tpoint
->orig_size
);
3745 else if (tpoint
->type
== static_tracepoint
)
3746 sprintf (packet
+ strlen (packet
), ":S");
3750 buf
= gdb_unparse_agent_expr (tpoint
->cond
);
3751 sprintf (packet
+ strlen (packet
), ":X%x,%s",
3752 tpoint
->cond
->length
, buf
);
3757 /* Compose a response that is an imitation of the syntax by which the
3758 tracepoint action was originally downloaded (with the difference
3759 that due to the way we store the actions, this will output a packet
3760 per action, while GDB could have combined more than one action
3764 response_action (char *packet
, struct tracepoint
*tpoint
,
3765 char *taction
, int step
)
3767 sprintf (packet
, "%c%x:%s:%s",
3768 (step
? 'S' : 'A'), tpoint
->number
, paddress (tpoint
->address
),
3772 /* Compose a response that is an imitation of the syntax by which the
3773 tracepoint source piece was originally downloaded. */
3776 response_source (char *packet
,
3777 struct tracepoint
*tpoint
, struct source_string
*src
)
3782 len
= strlen (src
->str
);
3783 buf
= alloca (len
* 2 + 1);
3784 convert_int_to_ascii ((gdb_byte
*) src
->str
, buf
, len
);
3786 sprintf (packet
, "Z%x:%s:%s:%x:%x:%s",
3787 tpoint
->number
, paddress (tpoint
->address
),
3788 src
->type
, 0, len
, buf
);
3791 /* Return the first piece of tracepoint definition, and initialize the
3792 state machine that will iterate through all the tracepoint
3796 cmd_qtfp (char *packet
)
3798 trace_debug ("Returning first tracepoint definition piece");
3800 cur_tpoint
= tracepoints
;
3801 cur_action
= cur_step_action
= 0;
3802 cur_source_string
= NULL
;
3805 response_tracepoint (packet
, cur_tpoint
);
3807 strcpy (packet
, "l");
3810 /* Return additional pieces of tracepoint definition. Each action and
3811 stepping action must go into its own packet, because of packet size
3812 limits, and so we use state variables to deliver one piece at a
3816 cmd_qtsp (char *packet
)
3818 trace_debug ("Returning subsequent tracepoint definition piece");
3822 /* This case would normally never occur, but be prepared for
3824 strcpy (packet
, "l");
3826 else if (cur_action
< cur_tpoint
->numactions
)
3828 response_action (packet
, cur_tpoint
,
3829 cur_tpoint
->actions_str
[cur_action
], 0);
3832 else if (cur_step_action
< cur_tpoint
->num_step_actions
)
3834 response_action (packet
, cur_tpoint
,
3835 cur_tpoint
->step_actions_str
[cur_step_action
], 1);
3838 else if ((cur_source_string
3839 ? cur_source_string
->next
3840 : cur_tpoint
->source_strings
))
3842 if (cur_source_string
)
3843 cur_source_string
= cur_source_string
->next
;
3845 cur_source_string
= cur_tpoint
->source_strings
;
3846 response_source (packet
, cur_tpoint
, cur_source_string
);
3850 cur_tpoint
= cur_tpoint
->next
;
3851 cur_action
= cur_step_action
= 0;
3852 cur_source_string
= NULL
;
3854 response_tracepoint (packet
, cur_tpoint
);
3856 strcpy (packet
, "l");
3860 /* Compose a response that is an imitation of the syntax by which the
3861 trace state variable was originally downloaded. */
3864 response_tsv (char *packet
, struct trace_state_variable
*tsv
)
3866 char *buf
= (char *) "";
3871 namelen
= strlen (tsv
->name
);
3872 buf
= alloca (namelen
* 2 + 1);
3873 convert_int_to_ascii ((gdb_byte
*) tsv
->name
, buf
, namelen
);
3876 sprintf (packet
, "%x:%s:%x:%s", tsv
->number
, phex_nz (tsv
->initial_value
, 0),
3877 tsv
->getter
? 1 : 0, buf
);
3880 /* Return the first trace state variable definition, and initialize
3881 the state machine that will iterate through all the tsv bits. */
3884 cmd_qtfv (char *packet
)
3886 trace_debug ("Returning first trace state variable definition");
3888 cur_tsv
= trace_state_variables
;
3891 response_tsv (packet
, cur_tsv
);
3893 strcpy (packet
, "l");
3896 /* Return additional trace state variable definitions. */
3899 cmd_qtsv (char *packet
)
3901 trace_debug ("Returning additional trace state variable definition");
3905 cur_tsv
= cur_tsv
->next
;
3907 response_tsv (packet
, cur_tsv
);
3909 strcpy (packet
, "l");
3912 strcpy (packet
, "l");
3915 /* Return the first static tracepoint marker, and initialize the state
3916 machine that will iterate through all the static tracepoints
3920 cmd_qtfstm (char *packet
)
3922 if (!maybe_write_ipa_ust_not_loaded (packet
))
3923 run_inferior_command (packet
, strlen (packet
) + 1);
3926 /* Return additional static tracepoints markers. */
3929 cmd_qtsstm (char *packet
)
3931 if (!maybe_write_ipa_ust_not_loaded (packet
))
3932 run_inferior_command (packet
, strlen (packet
) + 1);
3935 /* Return the definition of the static tracepoint at a given address.
3936 Result packet is the same as qTsST's. */
3939 cmd_qtstmat (char *packet
)
3941 if (!maybe_write_ipa_ust_not_loaded (packet
))
3942 run_inferior_command (packet
, strlen (packet
) + 1);
3945 /* Sent the agent a command to close it. */
3948 gdb_agent_about_to_close (int pid
)
3950 char buf
[IPA_CMD_BUF_SIZE
];
3952 if (!maybe_write_ipa_not_loaded (buf
))
3954 struct thread_info
*save_inferior
;
3955 struct inferior_list_entry
*inf
= all_threads
.head
;
3957 save_inferior
= current_inferior
;
3959 /* Find a certain thread which belongs to process PID. */
3962 if (ptid_get_pid (inf
->id
) == pid
)
3967 current_inferior
= (struct thread_info
*) inf
;
3969 strcpy (buf
, "close");
3971 run_inferior_command (buf
, strlen (buf
) + 1);
3973 current_inferior
= save_inferior
;
3977 /* Return the minimum instruction size needed for fast tracepoints as a
3978 hexadecimal number. */
3981 cmd_qtminftpilen (char *packet
)
3983 if (current_inferior
== NULL
)
3985 /* Indicate that the minimum length is currently unknown. */
3986 strcpy (packet
, "0");
3990 sprintf (packet
, "%x", target_get_min_fast_tracepoint_insn_len ());
3993 /* Respond to qTBuffer packet with a block of raw data from the trace
3994 buffer. GDB may ask for a lot, but we are allowed to reply with
3995 only as much as will fit within packet limits or whatever. */
3998 cmd_qtbuffer (char *own_buf
)
4000 ULONGEST offset
, num
, tot
;
4002 char *packet
= own_buf
;
4004 packet
+= strlen ("qTBuffer:");
4006 packet
= unpack_varlen_hex (packet
, &offset
);
4007 ++packet
; /* skip a comma */
4008 unpack_varlen_hex (packet
, &num
);
4010 trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s",
4011 (int) num
, phex_nz (offset
, 0));
4013 tot
= (trace_buffer_hi
- trace_buffer_lo
) - free_space ();
4015 /* If we're right at the end, reply specially that we're done. */
4018 strcpy (own_buf
, "l");
4022 /* Object to any other out-of-bounds request. */
4025 write_enn (own_buf
);
4029 /* Compute the pointer corresponding to the given offset, accounting
4031 tbp
= trace_buffer_start
+ offset
;
4032 if (tbp
>= trace_buffer_wrap
)
4033 tbp
-= (trace_buffer_wrap
- trace_buffer_lo
);
4035 /* Trim to the remaining bytes if we're close to the end. */
4036 if (num
> tot
- offset
)
4039 /* Trim to available packet size. */
4040 if (num
>= (PBUFSIZ
- 16) / 2 )
4041 num
= (PBUFSIZ
- 16) / 2;
4043 convert_int_to_ascii (tbp
, own_buf
, num
);
4047 cmd_bigqtbuffer_circular (char *own_buf
)
4050 char *packet
= own_buf
;
4052 packet
+= strlen ("QTBuffer:circular:");
4054 unpack_varlen_hex (packet
, &val
);
4055 circular_trace_buffer
= val
;
4056 trace_debug ("Trace buffer is now %s",
4057 circular_trace_buffer
? "circular" : "linear");
4062 cmd_bigqtbuffer_size (char *own_buf
)
4066 char *packet
= own_buf
;
4068 /* Can't change the size during a tracing run. */
4071 write_enn (own_buf
);
4075 packet
+= strlen ("QTBuffer:size:");
4077 /* -1 is sent as literal "-1". */
4078 if (strcmp (packet
, "-1") == 0)
4079 sval
= DEFAULT_TRACE_BUFFER_SIZE
;
4082 unpack_varlen_hex (packet
, &val
);
4083 sval
= (LONGEST
) val
;
4086 init_trace_buffer (sval
);
4087 trace_debug ("Trace buffer is now %s bytes",
4088 plongest (trace_buffer_size
));
4093 cmd_qtnotes (char *own_buf
)
4096 char *saved
, *user
, *notes
, *stopnote
;
4097 char *packet
= own_buf
;
4099 packet
+= strlen ("QTNotes:");
4103 if (strncmp ("user:", packet
, strlen ("user:")) == 0)
4105 packet
+= strlen ("user:");
4107 packet
= strchr (packet
, ';');
4108 nbytes
= (packet
- saved
) / 2;
4109 user
= xmalloc (nbytes
+ 1);
4110 nbytes
= unhexify (user
, saved
, nbytes
);
4111 user
[nbytes
] = '\0';
4112 ++packet
; /* skip the semicolon */
4113 trace_debug ("User is '%s'", user
);
4114 xfree (tracing_user_name
);
4115 tracing_user_name
= user
;
4117 else if (strncmp ("notes:", packet
, strlen ("notes:")) == 0)
4119 packet
+= strlen ("notes:");
4121 packet
= strchr (packet
, ';');
4122 nbytes
= (packet
- saved
) / 2;
4123 notes
= xmalloc (nbytes
+ 1);
4124 nbytes
= unhexify (notes
, saved
, nbytes
);
4125 notes
[nbytes
] = '\0';
4126 ++packet
; /* skip the semicolon */
4127 trace_debug ("Notes is '%s'", notes
);
4128 xfree (tracing_notes
);
4129 tracing_notes
= notes
;
4131 else if (strncmp ("tstop:", packet
, strlen ("tstop:")) == 0)
4133 packet
+= strlen ("tstop:");
4135 packet
= strchr (packet
, ';');
4136 nbytes
= (packet
- saved
) / 2;
4137 stopnote
= xmalloc (nbytes
+ 1);
4138 nbytes
= unhexify (stopnote
, saved
, nbytes
);
4139 stopnote
[nbytes
] = '\0';
4140 ++packet
; /* skip the semicolon */
4141 trace_debug ("tstop note is '%s'", stopnote
);
4142 xfree (tracing_stop_note
);
4143 tracing_stop_note
= stopnote
;
4153 handle_tracepoint_general_set (char *packet
)
4155 if (strcmp ("QTinit", packet
) == 0)
4157 cmd_qtinit (packet
);
4160 else if (strncmp ("QTDP:", packet
, strlen ("QTDP:")) == 0)
4165 else if (strncmp ("QTDPsrc:", packet
, strlen ("QTDPsrc:")) == 0)
4167 cmd_qtdpsrc (packet
);
4170 else if (strncmp ("QTEnable:", packet
, strlen ("QTEnable:")) == 0)
4172 cmd_qtenable_disable (packet
, 1);
4175 else if (strncmp ("QTDisable:", packet
, strlen ("QTDisable:")) == 0)
4177 cmd_qtenable_disable (packet
, 0);
4180 else if (strncmp ("QTDV:", packet
, strlen ("QTDV:")) == 0)
4185 else if (strncmp ("QTro:", packet
, strlen ("QTro:")) == 0)
4190 else if (strcmp ("QTStart", packet
) == 0)
4192 cmd_qtstart (packet
);
4195 else if (strcmp ("QTStop", packet
) == 0)
4197 cmd_qtstop (packet
);
4200 else if (strncmp ("QTDisconnected:", packet
,
4201 strlen ("QTDisconnected:")) == 0)
4203 cmd_qtdisconnected (packet
);
4206 else if (strncmp ("QTFrame:", packet
, strlen ("QTFrame:")) == 0)
4208 cmd_qtframe (packet
);
4211 else if (strncmp ("QTBuffer:circular:", packet
, strlen ("QTBuffer:circular:")) == 0)
4213 cmd_bigqtbuffer_circular (packet
);
4216 else if (strncmp ("QTBuffer:size:", packet
, strlen ("QTBuffer:size:")) == 0)
4218 cmd_bigqtbuffer_size (packet
);
4221 else if (strncmp ("QTNotes:", packet
, strlen ("QTNotes:")) == 0)
4223 cmd_qtnotes (packet
);
4231 handle_tracepoint_query (char *packet
)
4233 if (strcmp ("qTStatus", packet
) == 0)
4235 cmd_qtstatus (packet
);
4238 else if (strncmp ("qTP:", packet
, strlen ("qTP:")) == 0)
4243 else if (strcmp ("qTfP", packet
) == 0)
4248 else if (strcmp ("qTsP", packet
) == 0)
4253 else if (strcmp ("qTfV", packet
) == 0)
4258 else if (strcmp ("qTsV", packet
) == 0)
4263 else if (strncmp ("qTV:", packet
, strlen ("qTV:")) == 0)
4268 else if (strncmp ("qTBuffer:", packet
, strlen ("qTBuffer:")) == 0)
4270 cmd_qtbuffer (packet
);
4273 else if (strcmp ("qTfSTM", packet
) == 0)
4275 cmd_qtfstm (packet
);
4278 else if (strcmp ("qTsSTM", packet
) == 0)
4280 cmd_qtsstm (packet
);
4283 else if (strncmp ("qTSTMat:", packet
, strlen ("qTSTMat:")) == 0)
4285 cmd_qtstmat (packet
);
4288 else if (strcmp ("qTMinFTPILen", packet
) == 0)
4290 cmd_qtminftpilen (packet
);
4298 #ifndef IN_PROCESS_AGENT
4300 /* Call this when thread TINFO has hit the tracepoint defined by
4301 TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping
4302 action. This adds a while-stepping collecting state item to the
4303 threads' collecting state list, so that we can keep track of
4304 multiple simultaneous while-stepping actions being collected by the
4305 same thread. This can happen in cases like:
4307 ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs
4309 ff0003 INSN3 <-- TP2, collect $regs
4310 ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs
4313 Notice that when instruction INSN5 is reached, the while-stepping
4314 actions of both TP1 and TP3 are still being collected, and that TP2
4315 had been collected meanwhile. The whole range of ff0001-ff0005
4316 should be single-stepped, due to at least TP1's while-stepping
4317 action covering the whole range. */
4320 add_while_stepping_state (struct thread_info
*tinfo
,
4321 int tp_number
, CORE_ADDR tp_address
)
4323 struct wstep_state
*wstep
;
4325 wstep
= xmalloc (sizeof (*wstep
));
4326 wstep
->next
= tinfo
->while_stepping
;
4328 wstep
->tp_number
= tp_number
;
4329 wstep
->tp_address
= tp_address
;
4330 wstep
->current_step
= 0;
4332 tinfo
->while_stepping
= wstep
;
4335 /* Release the while-stepping collecting state WSTEP. */
4338 release_while_stepping_state (struct wstep_state
*wstep
)
4343 /* Release all while-stepping collecting states currently associated
4344 with thread TINFO. */
4347 release_while_stepping_state_list (struct thread_info
*tinfo
)
4349 struct wstep_state
*head
;
4351 while (tinfo
->while_stepping
)
4353 head
= tinfo
->while_stepping
;
4354 tinfo
->while_stepping
= head
->next
;
4355 release_while_stepping_state (head
);
4359 /* If TINFO was handling a 'while-stepping' action, the step has
4360 finished, so collect any step data needed, and check if any more
4361 steps are required. Return true if the thread was indeed
4362 collecting tracepoint data, false otherwise. */
4365 tracepoint_finished_step (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4367 struct tracepoint
*tpoint
;
4368 struct wstep_state
*wstep
;
4369 struct wstep_state
**wstep_link
;
4370 struct trap_tracepoint_ctx ctx
;
4372 /* Pull in fast tracepoint trace frames from the inferior lib buffer into
4374 if (agent_loaded_p ())
4375 upload_fast_traceframes ();
4377 /* Check if we were indeed collecting data for one of more
4378 tracepoints with a 'while-stepping' count. */
4379 if (tinfo
->while_stepping
== NULL
)
4384 /* We're not even tracing anymore. Stop this thread from
4386 release_while_stepping_state_list (tinfo
);
4388 /* The thread had stopped due to a single-step request indeed
4389 explained by a tracepoint. */
4393 wstep
= tinfo
->while_stepping
;
4394 wstep_link
= &tinfo
->while_stepping
;
4396 trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
4397 target_pid_to_str (tinfo
->entry
.id
),
4398 wstep
->tp_number
, paddress (wstep
->tp_address
));
4400 ctx
.base
.type
= trap_tracepoint
;
4401 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4403 while (wstep
!= NULL
)
4405 tpoint
= find_tracepoint (wstep
->tp_number
, wstep
->tp_address
);
4408 trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
4409 wstep
->tp_number
, paddress (wstep
->tp_address
),
4410 target_pid_to_str (tinfo
->entry
.id
));
4413 *wstep_link
= wstep
->next
;
4414 release_while_stepping_state (wstep
);
4415 wstep
= *wstep_link
;
4419 /* We've just finished one step. */
4420 ++wstep
->current_step
;
4423 collect_data_at_step ((struct tracepoint_hit_ctx
*) &ctx
,
4424 stop_pc
, tpoint
, wstep
->current_step
);
4426 if (wstep
->current_step
>= tpoint
->step_count
)
4428 /* The requested numbers of steps have occurred. */
4429 trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
4430 target_pid_to_str (tinfo
->entry
.id
),
4431 wstep
->tp_number
, paddress (wstep
->tp_address
));
4433 /* Unlink the wstep. */
4434 *wstep_link
= wstep
->next
;
4435 release_while_stepping_state (wstep
);
4436 wstep
= *wstep_link
;
4438 /* Only check the hit count now, which ensure that we do all
4439 our stepping before stopping the run. */
4440 if (tpoint
->pass_count
> 0
4441 && tpoint
->hit_count
>= tpoint
->pass_count
4442 && stopping_tracepoint
== NULL
)
4443 stopping_tracepoint
= tpoint
;
4447 /* Keep single-stepping until the requested numbers of steps
4449 wstep_link
= &wstep
->next
;
4450 wstep
= *wstep_link
;
4453 if (stopping_tracepoint
4454 || trace_buffer_is_full
4455 || expr_eval_result
!= expr_eval_no_error
)
4465 /* Handle any internal tracing control breakpoint hits. That means,
4466 pull traceframes from the IPA to our buffer, and syncing both
4467 tracing agents when the IPA's tracing stops for some reason. */
4470 handle_tracepoint_bkpts (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4472 /* Pull in fast tracepoint trace frames from the inferior in-process
4473 agent's buffer into our buffer. */
4475 if (!agent_loaded_p ())
4478 upload_fast_traceframes ();
4480 /* Check if the in-process agent had decided we should stop
4482 if (stop_pc
== ipa_sym_addrs
.addr_stop_tracing
)
4484 int ipa_trace_buffer_is_full
;
4485 CORE_ADDR ipa_stopping_tracepoint
;
4486 int ipa_expr_eval_result
;
4487 CORE_ADDR ipa_error_tracepoint
;
4489 trace_debug ("lib stopped at stop_tracing");
4491 read_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
,
4492 &ipa_trace_buffer_is_full
);
4494 read_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
4495 &ipa_stopping_tracepoint
);
4496 write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
, 0);
4498 read_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
,
4499 &ipa_error_tracepoint
);
4500 write_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
, 0);
4502 read_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
,
4503 &ipa_expr_eval_result
);
4504 write_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
, 0);
4506 trace_debug ("lib: trace_buffer_is_full: %d, "
4507 "stopping_tracepoint: %s, "
4508 "ipa_expr_eval_result: %d, "
4509 "error_tracepoint: %s, ",
4510 ipa_trace_buffer_is_full
,
4511 paddress (ipa_stopping_tracepoint
),
4512 ipa_expr_eval_result
,
4513 paddress (ipa_error_tracepoint
));
4517 if (ipa_trace_buffer_is_full
)
4518 trace_debug ("lib stopped due to full buffer.");
4519 if (ipa_stopping_tracepoint
)
4520 trace_debug ("lib stopped due to tpoint");
4521 if (ipa_stopping_tracepoint
)
4522 trace_debug ("lib stopped due to error");
4525 if (ipa_stopping_tracepoint
!= 0)
4528 = fast_tracepoint_from_ipa_tpoint_address (ipa_stopping_tracepoint
);
4530 else if (ipa_expr_eval_result
!= expr_eval_no_error
)
4532 expr_eval_result
= ipa_expr_eval_result
;
4534 = fast_tracepoint_from_ipa_tpoint_address (ipa_error_tracepoint
);
4539 else if (stop_pc
== ipa_sym_addrs
.addr_flush_trace_buffer
)
4541 trace_debug ("lib stopped at flush_trace_buffer");
4548 /* Return true if TINFO just hit a tracepoint. Collect data if
4552 tracepoint_was_hit (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4554 struct tracepoint
*tpoint
;
4556 struct trap_tracepoint_ctx ctx
;
4558 /* Not tracing, don't handle. */
4562 ctx
.base
.type
= trap_tracepoint
;
4563 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4565 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
4567 /* Note that we collect fast tracepoints here as well. We'll
4568 step over the fast tracepoint jump later, which avoids the
4569 double collect. However, we don't collect for static
4570 tracepoints here, because UST markers are compiled in program,
4571 and probes will be executed in program. So static tracepoints
4572 are collected there. */
4573 if (tpoint
->enabled
&& stop_pc
== tpoint
->address
4574 && tpoint
->type
!= static_tracepoint
)
4576 trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
4577 target_pid_to_str (tinfo
->entry
.id
),
4578 tpoint
->number
, paddress (tpoint
->address
));
4580 /* Test the condition if present, and collect if true. */
4582 || (condition_true_at_tracepoint
4583 ((struct tracepoint_hit_ctx
*) &ctx
, tpoint
)))
4584 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
4587 if (stopping_tracepoint
4588 || trace_buffer_is_full
4589 || expr_eval_result
!= expr_eval_no_error
)
4593 /* If the tracepoint had a 'while-stepping' action, then set
4594 the thread to collect this tracepoint on the following
4596 else if (tpoint
->step_count
> 0)
4598 add_while_stepping_state (tinfo
,
4599 tpoint
->number
, tpoint
->address
);
4611 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4612 struct ust_marker_data
;
4613 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4614 struct traceframe
*tframe
);
4617 /* Create a trace frame for the hit of the given tracepoint in the
4621 collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
, CORE_ADDR stop_pc
,
4622 struct tracepoint
*tpoint
)
4624 struct traceframe
*tframe
;
4627 /* Only count it as a hit when we actually collect data. */
4628 tpoint
->hit_count
++;
4630 /* If we've exceeded a defined pass count, record the event for
4631 later, and finish the collection for this hit. This test is only
4632 for nonstepping tracepoints, stepping tracepoints test at the end
4633 of their while-stepping loop. */
4634 if (tpoint
->pass_count
> 0
4635 && tpoint
->hit_count
>= tpoint
->pass_count
4636 && tpoint
->step_count
== 0
4637 && stopping_tracepoint
== NULL
)
4638 stopping_tracepoint
= tpoint
;
4640 trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64
,
4641 tpoint
->number
, paddress (tpoint
->address
), tpoint
->hit_count
);
4643 tframe
= add_traceframe (tpoint
);
4647 for (acti
= 0; acti
< tpoint
->numactions
; ++acti
)
4649 #ifndef IN_PROCESS_AGENT
4650 trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
4651 tpoint
->number
, paddress (tpoint
->address
),
4652 tpoint
->actions_str
[acti
]);
4655 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4656 tpoint
->actions
[acti
]);
4659 finish_traceframe (tframe
);
4662 if (tframe
== NULL
&& tracing
)
4663 trace_buffer_is_full
= 1;
4666 #ifndef IN_PROCESS_AGENT
4669 collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
4671 struct tracepoint
*tpoint
, int current_step
)
4673 struct traceframe
*tframe
;
4676 trace_debug ("Making new step traceframe for "
4677 "tracepoint %d at 0x%s, step %d of %" PRIu64
", hit %" PRIu64
,
4678 tpoint
->number
, paddress (tpoint
->address
),
4679 current_step
, tpoint
->step_count
,
4682 tframe
= add_traceframe (tpoint
);
4686 for (acti
= 0; acti
< tpoint
->num_step_actions
; ++acti
)
4688 trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'",
4689 tpoint
->number
, paddress (tpoint
->address
),
4690 tpoint
->step_actions_str
[acti
]);
4692 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4693 tpoint
->step_actions
[acti
]);
4696 finish_traceframe (tframe
);
4699 if (tframe
== NULL
&& tracing
)
4700 trace_buffer_is_full
= 1;
4705 #ifdef IN_PROCESS_AGENT
4706 /* The target description used by the IPA. Given that the IPA library
4707 is built for a specific architecture that is loaded into the
4708 inferior, there only needs to be one such description per
4710 const struct target_desc
*ipa_tdesc
;
4713 static struct regcache
*
4714 get_context_regcache (struct tracepoint_hit_ctx
*ctx
)
4716 struct regcache
*regcache
= NULL
;
4718 #ifdef IN_PROCESS_AGENT
4719 if (ctx
->type
== fast_tracepoint
)
4721 struct fast_tracepoint_ctx
*fctx
= (struct fast_tracepoint_ctx
*) ctx
;
4722 if (!fctx
->regcache_initted
)
4724 fctx
->regcache_initted
= 1;
4725 init_register_cache (&fctx
->regcache
, ipa_tdesc
, fctx
->regspace
);
4726 supply_regblock (&fctx
->regcache
, NULL
);
4727 supply_fast_tracepoint_registers (&fctx
->regcache
, fctx
->regs
);
4729 regcache
= &fctx
->regcache
;
4732 if (ctx
->type
== static_tracepoint
)
4734 struct static_tracepoint_ctx
*sctx
4735 = (struct static_tracepoint_ctx
*) ctx
;
4737 if (!sctx
->regcache_initted
)
4739 sctx
->regcache_initted
= 1;
4740 init_register_cache (&sctx
->regcache
, ipa_tdesc
, sctx
->regspace
);
4741 supply_regblock (&sctx
->regcache
, NULL
);
4742 /* Pass down the tracepoint address, because REGS doesn't
4743 include the PC, but we know what it must have been. */
4744 supply_static_tracepoint_registers (&sctx
->regcache
,
4745 (const unsigned char *)
4747 sctx
->tpoint
->address
);
4749 regcache
= &sctx
->regcache
;
4753 if (ctx
->type
== trap_tracepoint
)
4755 struct trap_tracepoint_ctx
*tctx
= (struct trap_tracepoint_ctx
*) ctx
;
4756 regcache
= tctx
->regcache
;
4760 gdb_assert (regcache
!= NULL
);
4766 do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4768 struct tracepoint
*tpoint
,
4769 struct traceframe
*tframe
,
4770 struct tracepoint_action
*taction
)
4772 enum eval_result_type err
;
4774 switch (taction
->type
)
4778 struct collect_memory_action
*maction
;
4779 struct eval_agent_expr_context ax_ctx
;
4781 maction
= (struct collect_memory_action
*) taction
;
4782 ax_ctx
.regcache
= NULL
;
4783 ax_ctx
.tframe
= tframe
;
4784 ax_ctx
.tpoint
= tpoint
;
4786 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
4787 pulongest (maction
->len
),
4788 paddress (maction
->addr
), maction
->basereg
);
4789 /* (should use basereg) */
4790 agent_mem_read (&ax_ctx
, NULL
, (CORE_ADDR
) maction
->addr
,
4796 unsigned char *regspace
;
4797 struct regcache tregcache
;
4798 struct regcache
*context_regcache
;
4801 trace_debug ("Want to collect registers");
4803 context_regcache
= get_context_regcache (ctx
);
4804 regcache_size
= register_cache_size (context_regcache
->tdesc
);
4806 /* Collect all registers for now. */
4807 regspace
= add_traceframe_block (tframe
, tpoint
, 1 + regcache_size
);
4808 if (regspace
== NULL
)
4810 trace_debug ("Trace buffer block allocation failed, skipping");
4813 /* Identify a register block. */
4816 /* Wrap the regblock in a register cache (in the stack, we
4817 don't want to malloc here). */
4818 init_register_cache (&tregcache
, context_regcache
->tdesc
,
4821 /* Copy the register data to the regblock. */
4822 regcache_cpy (&tregcache
, context_regcache
);
4824 #ifndef IN_PROCESS_AGENT
4825 /* On some platforms, trap-based tracepoints will have the PC
4826 pointing to the next instruction after the trap, but we
4827 don't want the user or GDB trying to guess whether the
4828 saved PC needs adjusting; so always record the adjusted
4829 stop_pc. Note that we can't use tpoint->address instead,
4830 since it will be wrong for while-stepping actions. This
4831 adjustment is a nop for fast tracepoints collected from the
4832 in-process lib (but not if GDBserver is collecting one
4833 preemptively), since the PC had already been adjusted to
4834 contain the tracepoint's address by the jump pad. */
4835 trace_debug ("Storing stop pc (0x%s) in regblock",
4836 paddress (stop_pc
));
4838 /* This changes the regblock, not the thread's
4840 regcache_write_pc (&tregcache
, stop_pc
);
4846 struct eval_expr_action
*eaction
;
4847 struct eval_agent_expr_context ax_ctx
;
4849 eaction
= (struct eval_expr_action
*) taction
;
4850 ax_ctx
.regcache
= get_context_regcache (ctx
);
4851 ax_ctx
.tframe
= tframe
;
4852 ax_ctx
.tpoint
= tpoint
;
4854 trace_debug ("Want to evaluate expression");
4856 err
= gdb_eval_agent_expr (&ax_ctx
, eaction
->expr
, NULL
);
4858 if (err
!= expr_eval_no_error
)
4860 record_tracepoint_error (tpoint
, "action expression", err
);
4867 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4868 trace_debug ("Want to collect static trace data");
4869 collect_ust_data_at_tracepoint (ctx
, tframe
);
4871 trace_debug ("warning: collecting static trace data, "
4872 "but static tracepoints are not supported");
4877 trace_debug ("unknown trace action '%c', ignoring", taction
->type
);
4883 condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4884 struct tracepoint
*tpoint
)
4887 enum eval_result_type err
;
4889 /* Presently, gdbserver doesn't run compiled conditions, only the
4890 IPA does. If the program stops at a fast tracepoint's address
4891 (e.g., due to a breakpoint, trap tracepoint, or stepping),
4892 gdbserver preemptively collect the fast tracepoint. Later, on
4893 resume, gdbserver steps over the fast tracepoint like it steps
4894 over breakpoints, so that the IPA doesn't see that fast
4895 tracepoint. This avoids double collects of fast tracepoints in
4896 that stopping scenario. Having gdbserver itself handle the fast
4897 tracepoint gives the user a consistent view of when fast or trap
4898 tracepoints are collected, compared to an alternative where only
4899 trap tracepoints are collected on stop, and fast tracepoints on
4900 resume. When a fast tracepoint is being processed by gdbserver,
4901 it is always the non-compiled condition expression that is
4903 #ifdef IN_PROCESS_AGENT
4904 if (tpoint
->compiled_cond
)
4905 err
= ((condfn
) (uintptr_t) (tpoint
->compiled_cond
)) (ctx
, &value
);
4909 struct eval_agent_expr_context ax_ctx
;
4911 ax_ctx
.regcache
= get_context_regcache (ctx
);
4912 ax_ctx
.tframe
= NULL
;
4913 ax_ctx
.tpoint
= tpoint
;
4915 err
= gdb_eval_agent_expr (&ax_ctx
, tpoint
->cond
, &value
);
4917 if (err
!= expr_eval_no_error
)
4919 record_tracepoint_error (tpoint
, "condition", err
);
4920 /* The error case must return false. */
4924 trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
4925 tpoint
->number
, paddress (tpoint
->address
),
4927 return (value
? 1 : 0);
4930 /* Do memory copies for bytecodes. */
4931 /* Do the recording of memory blocks for actions and bytecodes. */
4934 agent_mem_read (struct eval_agent_expr_context
*ctx
,
4935 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4937 unsigned char *mspace
;
4938 ULONGEST remaining
= len
;
4939 unsigned short blocklen
;
4941 /* If a 'to' buffer is specified, use it. */
4944 read_inferior_memory (from
, to
, len
);
4948 /* Otherwise, create a new memory block in the trace buffer. */
4949 while (remaining
> 0)
4953 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4954 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
4955 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
4958 /* Identify block as a memory block. */
4961 /* Record address and size. */
4962 memcpy (mspace
, &from
, sizeof (from
));
4963 mspace
+= sizeof (from
);
4964 memcpy (mspace
, &blocklen
, sizeof (blocklen
));
4965 mspace
+= sizeof (blocklen
);
4966 /* Record the memory block proper. */
4967 read_inferior_memory (from
, mspace
, blocklen
);
4968 trace_debug ("%d bytes recorded", blocklen
);
4969 remaining
-= blocklen
;
4976 agent_mem_read_string (struct eval_agent_expr_context
*ctx
,
4977 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4979 unsigned char *buf
, *mspace
;
4980 ULONGEST remaining
= len
;
4981 unsigned short blocklen
, i
;
4983 /* To save a bit of space, block lengths are 16-bit, so break large
4984 requests into multiple blocks. Bordering on overkill for strings,
4985 but it could happen that someone specifies a large max length. */
4986 while (remaining
> 0)
4990 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4991 /* We want working space to accumulate nonzero bytes, since
4992 traceframes must have a predecided size (otherwise it gets
4993 harder to wrap correctly for the circular case, etc). */
4994 buf
= (unsigned char *) xmalloc (blocklen
+ 1);
4995 for (i
= 0; i
< blocklen
; ++i
)
4997 /* Read the string one byte at a time, in case the string is
4998 at the end of a valid memory area - we don't want a
4999 correctly-terminated string to engender segvio
5001 read_inferior_memory (from
+ i
, buf
+ i
, 1);
5006 /* Make sure outer loop stops now too. */
5007 remaining
= blocklen
;
5011 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
5012 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
5018 /* Identify block as a memory block. */
5021 /* Record address and size. */
5022 memcpy ((void *) mspace
, (void *) &from
, sizeof (from
));
5023 mspace
+= sizeof (from
);
5024 memcpy ((void *) mspace
, (void *) &blocklen
, sizeof (blocklen
));
5025 mspace
+= sizeof (blocklen
);
5026 /* Copy the string contents. */
5027 memcpy ((void *) mspace
, (void *) buf
, blocklen
);
5028 remaining
-= blocklen
;
5035 /* Record the value of a trace state variable. */
5038 agent_tsv_read (struct eval_agent_expr_context
*ctx
, int n
)
5040 unsigned char *vspace
;
5043 vspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
,
5044 1 + sizeof (n
) + sizeof (LONGEST
));
5047 /* Identify block as a variable. */
5049 /* Record variable's number and value. */
5050 memcpy (vspace
+ 1, &n
, sizeof (n
));
5051 val
= get_trace_state_variable_value (n
);
5052 memcpy (vspace
+ 1 + sizeof (n
), &val
, sizeof (val
));
5053 trace_debug ("Variable %d recorded", n
);
5057 #ifndef IN_PROCESS_AGENT
5059 /* Callback for traceframe_walk_blocks, used to find a given block
5060 type in a traceframe. */
5063 match_blocktype (char blocktype
, unsigned char *dataptr
, void *data
)
5065 char *wantedp
= data
;
5067 if (*wantedp
== blocktype
)
5073 /* Walk over all traceframe blocks of the traceframe buffer starting
5074 at DATABASE, of DATASIZE bytes long, and call CALLBACK for each
5075 block found, passing in DATA unmodified. If CALLBACK returns true,
5076 this returns a pointer to where the block is found. Returns NULL
5077 if no callback call returned true, indicating that all blocks have
5080 static unsigned char *
5081 traceframe_walk_blocks (unsigned char *database
, unsigned int datasize
,
5083 int (*callback
) (char blocktype
,
5084 unsigned char *dataptr
,
5088 unsigned char *dataptr
;
5092 trace_debug ("traceframe %d has no data", tfnum
);
5096 /* Iterate through a traceframe's blocks, looking for a block of the
5098 for (dataptr
= database
;
5099 dataptr
< database
+ datasize
;
5103 unsigned short mlen
;
5105 if (dataptr
== trace_buffer_wrap
)
5107 /* Adjust to reflect wrapping part of the frame around to
5109 datasize
= dataptr
- database
;
5110 dataptr
= database
= trace_buffer_lo
;
5113 blocktype
= *dataptr
++;
5115 if ((*callback
) (blocktype
, dataptr
, data
))
5121 /* Skip over the registers block. */
5122 dataptr
+= current_target_desc ()->registers_size
;
5125 /* Skip over the memory block. */
5126 dataptr
+= sizeof (CORE_ADDR
);
5127 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5128 dataptr
+= (sizeof (mlen
) + mlen
);
5131 /* Skip over the TSV block. */
5132 dataptr
+= (sizeof (int) + sizeof (LONGEST
));
5135 /* Skip over the static trace data block. */
5136 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5137 dataptr
+= (sizeof (mlen
) + mlen
);
5140 trace_debug ("traceframe %d has unknown block type 0x%x",
5149 /* Look for the block of type TYPE_WANTED in the trameframe starting
5150 at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
5153 static unsigned char *
5154 traceframe_find_block_type (unsigned char *database
, unsigned int datasize
,
5155 int tfnum
, char type_wanted
)
5157 return traceframe_walk_blocks (database
, datasize
, tfnum
,
5158 match_blocktype
, &type_wanted
);
5161 static unsigned char *
5162 traceframe_find_regblock (struct traceframe
*tframe
, int tfnum
)
5164 unsigned char *regblock
;
5166 regblock
= traceframe_find_block_type (tframe
->data
,
5170 if (regblock
== NULL
)
5171 trace_debug ("traceframe %d has no register data", tfnum
);
5176 /* Get registers from a traceframe. */
5179 fetch_traceframe_registers (int tfnum
, struct regcache
*regcache
, int regnum
)
5181 unsigned char *dataptr
;
5182 struct tracepoint
*tpoint
;
5183 struct traceframe
*tframe
;
5185 tframe
= find_traceframe (tfnum
);
5189 trace_debug ("traceframe %d not found", tfnum
);
5193 dataptr
= traceframe_find_regblock (tframe
, tfnum
);
5194 if (dataptr
== NULL
)
5196 /* Mark registers unavailable. */
5197 supply_regblock (regcache
, NULL
);
5199 /* We can generally guess at a PC, although this will be
5200 misleading for while-stepping frames and multi-location
5202 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
5204 regcache_write_pc (regcache
, tpoint
->address
);
5207 supply_regblock (regcache
, dataptr
);
5213 traceframe_get_pc (struct traceframe
*tframe
)
5215 struct regcache regcache
;
5216 unsigned char *dataptr
;
5217 const struct target_desc
*tdesc
= current_target_desc ();
5219 dataptr
= traceframe_find_regblock (tframe
, -1);
5220 if (dataptr
== NULL
)
5223 init_register_cache (®cache
, tdesc
, dataptr
);
5224 return regcache_read_pc (®cache
);
5227 /* Read a requested block of memory from a trace frame. */
5230 traceframe_read_mem (int tfnum
, CORE_ADDR addr
,
5231 unsigned char *buf
, ULONGEST length
,
5234 struct traceframe
*tframe
;
5235 unsigned char *database
, *dataptr
;
5236 unsigned int datasize
;
5238 unsigned short mlen
;
5240 trace_debug ("traceframe_read_mem");
5242 tframe
= find_traceframe (tfnum
);
5246 trace_debug ("traceframe %d not found", tfnum
);
5250 datasize
= tframe
->data_size
;
5251 database
= dataptr
= &tframe
->data
[0];
5253 /* Iterate through a traceframe's blocks, looking for memory. */
5254 while ((dataptr
= traceframe_find_block_type (dataptr
,
5256 - (dataptr
- database
),
5257 tfnum
, 'M')) != NULL
)
5259 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5260 dataptr
+= sizeof (maddr
);
5261 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5262 dataptr
+= sizeof (mlen
);
5263 trace_debug ("traceframe %d has %d bytes at %s",
5264 tfnum
, mlen
, paddress (maddr
));
5266 /* If the block includes the first part of the desired range,
5267 return as much it has; GDB will re-request the remainder,
5268 which might be in a different block of this trace frame. */
5269 if (maddr
<= addr
&& addr
< (maddr
+ mlen
))
5271 ULONGEST amt
= (maddr
+ mlen
) - addr
;
5275 memcpy (buf
, dataptr
+ (addr
- maddr
), amt
);
5280 /* Skip over this block. */
5284 trace_debug ("traceframe %d has no memory data for the desired region",
5292 traceframe_read_tsv (int tsvnum
, LONGEST
*val
)
5295 struct traceframe
*tframe
;
5296 unsigned char *database
, *dataptr
;
5297 unsigned int datasize
;
5301 trace_debug ("traceframe_read_tsv");
5303 tfnum
= current_traceframe
;
5307 trace_debug ("no current traceframe");
5311 tframe
= find_traceframe (tfnum
);
5315 trace_debug ("traceframe %d not found", tfnum
);
5319 datasize
= tframe
->data_size
;
5320 database
= dataptr
= &tframe
->data
[0];
5322 /* Iterate through a traceframe's blocks, looking for the last
5324 while ((dataptr
= traceframe_find_block_type (dataptr
,
5326 - (dataptr
- database
),
5327 tfnum
, 'V')) != NULL
)
5329 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5330 dataptr
+= sizeof (vnum
);
5332 trace_debug ("traceframe %d has variable %d", tfnum
, vnum
);
5334 /* Check that this is the variable we want. */
5337 memcpy (val
, dataptr
, sizeof (*val
));
5341 /* Skip over this block. */
5342 dataptr
+= sizeof (LONGEST
);
5346 trace_debug ("traceframe %d has no data for variable %d",
5351 /* Read a requested block of static tracepoint data from a trace
5355 traceframe_read_sdata (int tfnum
, ULONGEST offset
,
5356 unsigned char *buf
, ULONGEST length
,
5359 struct traceframe
*tframe
;
5360 unsigned char *database
, *dataptr
;
5361 unsigned int datasize
;
5362 unsigned short mlen
;
5364 trace_debug ("traceframe_read_sdata");
5366 tframe
= find_traceframe (tfnum
);
5370 trace_debug ("traceframe %d not found", tfnum
);
5374 datasize
= tframe
->data_size
;
5375 database
= &tframe
->data
[0];
5377 /* Iterate through a traceframe's blocks, looking for static
5379 dataptr
= traceframe_find_block_type (database
, datasize
,
5381 if (dataptr
!= NULL
)
5383 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5384 dataptr
+= sizeof (mlen
);
5387 if (offset
+ length
> mlen
)
5388 length
= mlen
- offset
;
5390 memcpy (buf
, dataptr
, length
);
5398 trace_debug ("traceframe %d has no static trace data", tfnum
);
5404 /* Callback for traceframe_walk_blocks. Builds a traceframe-info
5405 object. DATA is pointer to a struct buffer holding the
5406 traceframe-info object being built. */
5409 build_traceframe_info_xml (char blocktype
, unsigned char *dataptr
, void *data
)
5411 struct buffer
*buffer
= data
;
5417 unsigned short mlen
;
5420 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5421 dataptr
+= sizeof (maddr
);
5422 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5423 dataptr
+= sizeof (mlen
);
5424 buffer_xml_printf (buffer
,
5425 "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5426 paddress (maddr
), phex_nz (mlen
, sizeof (mlen
)));
5433 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5434 buffer_xml_printf (buffer
, "<tvar id=\"%d\"/>\n", vnum
);
5443 warning ("Unhandled trace block type (%d) '%c ' "
5444 "while building trace frame info.",
5445 blocktype
, blocktype
);
5452 /* Build a traceframe-info object for traceframe number TFNUM into
5456 traceframe_read_info (int tfnum
, struct buffer
*buffer
)
5458 struct traceframe
*tframe
;
5460 trace_debug ("traceframe_read_info");
5462 tframe
= find_traceframe (tfnum
);
5466 trace_debug ("traceframe %d not found", tfnum
);
5470 buffer_grow_str (buffer
, "<traceframe-info>\n");
5471 traceframe_walk_blocks (tframe
->data
, tframe
->data_size
,
5472 tfnum
, build_traceframe_info_xml
, buffer
);
5473 buffer_grow_str0 (buffer
, "</traceframe-info>\n");
5477 /* Return the first fast tracepoint whose jump pad contains PC. */
5479 static struct tracepoint
*
5480 fast_tracepoint_from_jump_pad_address (CORE_ADDR pc
)
5482 struct tracepoint
*tpoint
;
5484 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5485 if (tpoint
->type
== fast_tracepoint
)
5486 if (tpoint
->jump_pad
<= pc
&& pc
< tpoint
->jump_pad_end
)
5492 /* Return the first fast tracepoint whose trampoline contains PC. */
5494 static struct tracepoint
*
5495 fast_tracepoint_from_trampoline_address (CORE_ADDR pc
)
5497 struct tracepoint
*tpoint
;
5499 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5501 if (tpoint
->type
== fast_tracepoint
5502 && tpoint
->trampoline
<= pc
&& pc
< tpoint
->trampoline_end
)
5509 /* Return GDBserver's tracepoint that matches the IP Agent's
5510 tracepoint object that lives at IPA_TPOINT_OBJ in the IP Agent's
5513 static struct tracepoint
*
5514 fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR ipa_tpoint_obj
)
5516 struct tracepoint
*tpoint
;
5518 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5519 if (tpoint
->type
== fast_tracepoint
)
5520 if (tpoint
->obj_addr_on_target
== ipa_tpoint_obj
)
5528 /* The type of the object that is used to synchronize fast tracepoint
5531 typedef struct collecting_t
5533 /* The fast tracepoint number currently collecting. */
5536 /* A number that GDBserver can use to identify the thread that is
5537 presently holding the collect lock. This need not (and usually
5538 is not) the thread id, as getting the current thread ID usually
5539 requires a system call, which we want to avoid like the plague.
5540 Usually this is thread's TCB, found in the TLS (pseudo-)
5541 register, which is readable with a single insn on several
5543 uintptr_t thread_area
;
5546 #ifndef IN_PROCESS_AGENT
5549 force_unlock_trace_buffer (void)
5551 write_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
, 0);
5554 /* Check if the thread identified by THREAD_AREA which is stopped at
5555 STOP_PC, is presently locking the fast tracepoint collection, and
5556 if so, gather some status of said collection. Returns 0 if the
5557 thread isn't collecting or in the jump pad at all. 1, if in the
5558 jump pad (or within gdb_collect) and hasn't executed the adjusted
5559 original insn yet (can set a breakpoint there and run to it). 2,
5560 if presently executing the adjusted original insn --- in which
5561 case, if we want to move the thread out of the jump pad, we need to
5562 single-step it until this function returns 0. */
5565 fast_tracepoint_collecting (CORE_ADDR thread_area
,
5567 struct fast_tpoint_collect_status
*status
)
5569 CORE_ADDR ipa_collecting
;
5570 CORE_ADDR ipa_gdb_jump_pad_buffer
, ipa_gdb_jump_pad_buffer_end
;
5571 CORE_ADDR ipa_gdb_trampoline_buffer
;
5572 CORE_ADDR ipa_gdb_trampoline_buffer_end
;
5573 struct tracepoint
*tpoint
;
5574 int needs_breakpoint
;
5576 /* The thread THREAD_AREA is either:
5578 0. not collecting at all, not within the jump pad, or within
5579 gdb_collect or one of its callees.
5581 1. in the jump pad and haven't reached gdb_collect
5583 2. within gdb_collect (out of the jump pad) (collect is set)
5585 3. we're in the jump pad, after gdb_collect having returned,
5586 possibly executing the adjusted insns.
5588 For cases 1 and 3, `collecting' may or not be set. The jump pad
5589 doesn't have any complicated jump logic, so we can tell if the
5590 thread is executing the adjust original insn or not by just
5591 matching STOP_PC with known jump pad addresses. If we it isn't
5592 yet executing the original insn, set a breakpoint there, and let
5593 the thread run to it, so to quickly step over a possible (many
5594 insns) gdb_collect call. Otherwise, or when the breakpoint is
5595 hit, only a few (small number of) insns are left to be executed
5596 in the jump pad. Single-step the thread until it leaves the
5601 needs_breakpoint
= 0;
5602 trace_debug ("fast_tracepoint_collecting");
5604 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
5605 &ipa_gdb_jump_pad_buffer
))
5606 fatal ("error extracting `gdb_jump_pad_buffer'");
5607 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer_end
,
5608 &ipa_gdb_jump_pad_buffer_end
))
5609 fatal ("error extracting `gdb_jump_pad_buffer_end'");
5611 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
5612 &ipa_gdb_trampoline_buffer
))
5613 fatal ("error extracting `gdb_trampoline_buffer'");
5614 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
5615 &ipa_gdb_trampoline_buffer_end
))
5616 fatal ("error extracting `gdb_trampoline_buffer_end'");
5618 if (ipa_gdb_jump_pad_buffer
<= stop_pc
5619 && stop_pc
< ipa_gdb_jump_pad_buffer_end
)
5621 /* We can tell which tracepoint(s) the thread is collecting by
5622 matching the jump pad address back to the tracepoint. */
5623 tpoint
= fast_tracepoint_from_jump_pad_address (stop_pc
);
5626 warning ("in jump pad, but no matching tpoint?");
5631 trace_debug ("in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5633 tpoint
->number
, paddress (tpoint
->address
),
5634 paddress (tpoint
->jump_pad
),
5635 paddress (tpoint
->jump_pad_end
),
5636 paddress (tpoint
->adjusted_insn_addr
),
5637 paddress (tpoint
->adjusted_insn_addr_end
));
5640 /* Definitely in the jump pad. May or may not need
5641 fast-exit-jump-pad breakpoint. */
5642 if (tpoint
->jump_pad
<= stop_pc
5643 && stop_pc
< tpoint
->adjusted_insn_addr
)
5644 needs_breakpoint
= 1;
5646 else if (ipa_gdb_trampoline_buffer
<= stop_pc
5647 && stop_pc
< ipa_gdb_trampoline_buffer_end
)
5649 /* We can tell which tracepoint(s) the thread is collecting by
5650 matching the trampoline address back to the tracepoint. */
5651 tpoint
= fast_tracepoint_from_trampoline_address (stop_pc
);
5654 warning ("in trampoline, but no matching tpoint?");
5659 trace_debug ("in trampoline of tpoint (%d, %s); trampoline(%s, %s)",
5660 tpoint
->number
, paddress (tpoint
->address
),
5661 paddress (tpoint
->trampoline
),
5662 paddress (tpoint
->trampoline_end
));
5665 /* Have not reached jump pad yet, but treat the trampoline as a
5666 part of the jump pad that is before the adjusted original
5668 needs_breakpoint
= 1;
5672 collecting_t ipa_collecting_obj
;
5674 /* If `collecting' is set/locked, then the THREAD_AREA thread
5675 may or not be the one holding the lock. We have to read the
5676 lock to find out. */
5678 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
,
5681 trace_debug ("fast_tracepoint_collecting:"
5682 " failed reading 'collecting' in the inferior");
5686 if (!ipa_collecting
)
5688 trace_debug ("fast_tracepoint_collecting: not collecting"
5689 " (and nobody is).");
5693 /* Some thread is collecting. Check which. */
5694 if (read_inferior_memory (ipa_collecting
,
5695 (unsigned char *) &ipa_collecting_obj
,
5696 sizeof (ipa_collecting_obj
)) != 0)
5699 if (ipa_collecting_obj
.thread_area
!= thread_area
)
5701 trace_debug ("fast_tracepoint_collecting: not collecting "
5702 "(another thread is)");
5707 = fast_tracepoint_from_ipa_tpoint_address (ipa_collecting_obj
.tpoint
);
5710 warning ("fast_tracepoint_collecting: collecting, "
5711 "but tpoint %s not found?",
5712 paddress ((CORE_ADDR
) ipa_collecting_obj
.tpoint
));
5716 /* The thread is within `gdb_collect', skip over the rest of
5717 fast tracepoint collection quickly using a breakpoint. */
5718 needs_breakpoint
= 1;
5721 /* The caller wants a bit of status detail. */
5724 status
->tpoint_num
= tpoint
->number
;
5725 status
->tpoint_addr
= tpoint
->address
;
5726 status
->adjusted_insn_addr
= tpoint
->adjusted_insn_addr
;
5727 status
->adjusted_insn_addr_end
= tpoint
->adjusted_insn_addr_end
;
5730 if (needs_breakpoint
)
5732 /* Hasn't executed the original instruction yet. Set breakpoint
5733 there, and wait till it's hit, then single-step until exiting
5737 fast_tracepoint_collecting, returning continue-until-break at %s",
5738 paddress (tpoint
->adjusted_insn_addr
));
5740 return 1; /* continue */
5744 /* Just single-step until exiting the jump pad. */
5746 trace_debug ("fast_tracepoint_collecting, returning "
5747 "need-single-step (%s-%s)",
5748 paddress (tpoint
->adjusted_insn_addr
),
5749 paddress (tpoint
->adjusted_insn_addr_end
));
5751 return 2; /* single-step */
5757 #ifdef IN_PROCESS_AGENT
5759 /* The global fast tracepoint collect lock. Points to a collecting_t
5760 object built on the stack by the jump pad, if presently locked;
5761 NULL if it isn't locked. Note that this lock *must* be set while
5762 executing any *function other than the jump pad. See
5763 fast_tracepoint_collecting. */
5764 static collecting_t
* ATTR_USED collecting
;
5766 /* This routine, called from the jump pad (in asm) is designed to be
5767 called from the jump pads of fast tracepoints, thus it is on the
5770 IP_AGENT_EXPORT
void ATTR_USED
5771 gdb_collect (struct tracepoint
*tpoint
, unsigned char *regs
)
5773 struct fast_tracepoint_ctx ctx
;
5775 /* Don't do anything until the trace run is completely set up. */
5779 ctx
.base
.type
= fast_tracepoint
;
5781 ctx
.regcache_initted
= 0;
5782 /* Wrap the regblock in a register cache (in the stack, we don't
5783 want to malloc here). */
5784 ctx
.regspace
= alloca (ipa_tdesc
->registers_size
);
5785 if (ctx
.regspace
== NULL
)
5787 trace_debug ("Trace buffer block allocation failed, skipping");
5791 for (ctx
.tpoint
= tpoint
;
5792 ctx
.tpoint
!= NULL
&& ctx
.tpoint
->address
== tpoint
->address
;
5793 ctx
.tpoint
= ctx
.tpoint
->next
)
5795 if (!ctx
.tpoint
->enabled
)
5798 /* Multiple tracepoints of different types, such as fast tracepoint and
5799 static tracepoint, can be set at the same address. */
5800 if (ctx
.tpoint
->type
!= tpoint
->type
)
5803 /* Test the condition if present, and collect if true. */
5804 if (ctx
.tpoint
->cond
== NULL
5805 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5808 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5809 ctx
.tpoint
->address
, ctx
.tpoint
);
5811 /* Note that this will cause original insns to be written back
5812 to where we jumped from, but that's OK because we're jumping
5813 back to the next whole instruction. This will go badly if
5814 instruction restoration is not atomic though. */
5815 if (stopping_tracepoint
5816 || trace_buffer_is_full
5817 || expr_eval_result
!= expr_eval_no_error
)
5825 /* If there was a condition and it evaluated to false, the only
5826 way we would stop tracing is if there was an error during
5827 condition expression evaluation. */
5828 if (expr_eval_result
!= expr_eval_no_error
)
5839 #ifndef IN_PROCESS_AGENT
5842 get_raw_reg_func_addr (void)
5844 return ipa_sym_addrs
.addr_get_raw_reg
;
5848 get_get_tsv_func_addr (void)
5850 return ipa_sym_addrs
.addr_get_trace_state_variable_value
;
5854 get_set_tsv_func_addr (void)
5856 return ipa_sym_addrs
.addr_set_trace_state_variable_value
;
5860 compile_tracepoint_condition (struct tracepoint
*tpoint
,
5861 CORE_ADDR
*jump_entry
)
5863 CORE_ADDR entry_point
= *jump_entry
;
5864 enum eval_result_type err
;
5866 trace_debug ("Starting condition compilation for tracepoint %d\n",
5869 /* Initialize the global pointer to the code being built. */
5870 current_insn_ptr
= *jump_entry
;
5874 err
= compile_bytecodes (tpoint
->cond
);
5876 if (err
== expr_eval_no_error
)
5880 /* Record the beginning of the compiled code. */
5881 tpoint
->compiled_cond
= entry_point
;
5883 trace_debug ("Condition compilation for tracepoint %d complete\n",
5888 /* Leave the unfinished code in situ, but don't point to it. */
5890 tpoint
->compiled_cond
= 0;
5892 trace_debug ("Condition compilation for tracepoint %d failed, "
5894 tpoint
->number
, err
);
5897 /* Update the code pointer passed in. Note that we do this even if
5898 the compile fails, so that we can look at the partial results
5899 instead of letting them be overwritten. */
5900 *jump_entry
= current_insn_ptr
;
5902 /* Leave a gap, to aid dump decipherment. */
5906 /* We'll need to adjust these when we consider bi-arch setups, and big
5910 write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
)
5912 return write_inferior_memory (where
,
5913 (unsigned char *) &ptr
, sizeof (void *));
5916 /* The base pointer of the IPA's heap. This is the only memory the
5917 IPA is allowed to use. The IPA should _not_ call the inferior's
5918 `malloc' during operation. That'd be slow, and, most importantly,
5919 it may not be safe. We may be collecting a tracepoint in a signal
5920 handler, for example. */
5921 static CORE_ADDR target_tp_heap
;
5923 /* Allocate at least SIZE bytes of memory from the IPA heap, aligned
5927 target_malloc (ULONGEST size
)
5931 if (target_tp_heap
== 0)
5933 /* We have the pointer *address*, need what it points to. */
5934 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_tp_heap_buffer
,
5936 fatal ("could get target heap head pointer");
5939 ptr
= target_tp_heap
;
5940 target_tp_heap
+= size
;
5942 /* Pad to 8-byte alignment. */
5943 target_tp_heap
= ((target_tp_heap
+ 7) & ~0x7);
5949 download_agent_expr (struct agent_expr
*expr
)
5951 CORE_ADDR expr_addr
;
5952 CORE_ADDR expr_bytes
;
5954 expr_addr
= target_malloc (sizeof (*expr
));
5955 write_inferior_memory (expr_addr
, (unsigned char *) expr
, sizeof (*expr
));
5957 expr_bytes
= target_malloc (expr
->length
);
5958 write_inferior_data_ptr (expr_addr
+ offsetof (struct agent_expr
, bytes
),
5960 write_inferior_memory (expr_bytes
, expr
->bytes
, expr
->length
);
5965 /* Align V up to N bits. */
5966 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
5968 /* Sync tracepoint with IPA, but leave maintenance of linked list to caller. */
5971 download_tracepoint_1 (struct tracepoint
*tpoint
)
5973 struct tracepoint target_tracepoint
;
5974 CORE_ADDR tpptr
= 0;
5976 gdb_assert (tpoint
->type
== fast_tracepoint
5977 || tpoint
->type
== static_tracepoint
);
5979 if (tpoint
->cond
!= NULL
&& target_emit_ops () != NULL
)
5981 CORE_ADDR jentry
, jump_entry
;
5983 jentry
= jump_entry
= get_jump_space_head ();
5985 if (tpoint
->cond
!= NULL
)
5987 /* Pad to 8-byte alignment. (needed?) */
5988 /* Actually this should be left for the target to
5990 jentry
= UALIGN (jentry
, 8);
5992 compile_tracepoint_condition (tpoint
, &jentry
);
5995 /* Pad to 8-byte alignment. */
5996 jentry
= UALIGN (jentry
, 8);
5997 claim_jump_space (jentry
- jump_entry
);
6000 target_tracepoint
= *tpoint
;
6002 tpptr
= target_malloc (sizeof (*tpoint
));
6003 tpoint
->obj_addr_on_target
= tpptr
;
6005 /* Write the whole object. We'll fix up its pointers in a bit.
6006 Assume no next for now. This is fixed up above on the next
6007 iteration, if there's any. */
6008 target_tracepoint
.next
= NULL
;
6009 /* Need to clear this here too, since we're downloading the
6010 tracepoints before clearing our own copy. */
6011 target_tracepoint
.hit_count
= 0;
6013 write_inferior_memory (tpptr
, (unsigned char *) &target_tracepoint
,
6014 sizeof (target_tracepoint
));
6017 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6019 download_agent_expr (tpoint
->cond
));
6021 if (tpoint
->numactions
)
6024 CORE_ADDR actions_array
;
6026 /* The pointers array. */
6028 = target_malloc (sizeof (*tpoint
->actions
) * tpoint
->numactions
);
6029 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6033 /* Now for each pointer, download the action. */
6034 for (i
= 0; i
< tpoint
->numactions
; i
++)
6036 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6037 CORE_ADDR ipa_action
= action
->ops
->download (action
);
6039 if (ipa_action
!= 0)
6040 write_inferior_data_ptr
6041 (actions_array
+ i
* sizeof (*tpoint
->actions
),
6047 #define IPA_PROTO_FAST_TRACE_FLAG 0
6048 #define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
6049 #define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
6050 #define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
6051 #define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
6053 /* Send a command to agent to download and install tracepoint TPOINT. */
6056 tracepoint_send_agent (struct tracepoint
*tpoint
)
6058 char buf
[IPA_CMD_BUF_SIZE
];
6063 strcpy (p
, "FastTrace:");
6066 COPY_FIELD_TO_BUF (p
, tpoint
, number
);
6067 COPY_FIELD_TO_BUF (p
, tpoint
, address
);
6068 COPY_FIELD_TO_BUF (p
, tpoint
, type
);
6069 COPY_FIELD_TO_BUF (p
, tpoint
, enabled
);
6070 COPY_FIELD_TO_BUF (p
, tpoint
, step_count
);
6071 COPY_FIELD_TO_BUF (p
, tpoint
, pass_count
);
6072 COPY_FIELD_TO_BUF (p
, tpoint
, numactions
);
6073 COPY_FIELD_TO_BUF (p
, tpoint
, hit_count
);
6074 COPY_FIELD_TO_BUF (p
, tpoint
, traceframe_usage
);
6075 COPY_FIELD_TO_BUF (p
, tpoint
, compiled_cond
);
6076 COPY_FIELD_TO_BUF (p
, tpoint
, orig_size
);
6079 p
= agent_expr_send (p
, tpoint
->cond
);
6081 /* tracepoint_action */
6082 for (i
= 0; i
< tpoint
->numactions
; i
++)
6084 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6086 p
[0] = action
->type
;
6087 p
= action
->ops
->send (&p
[1], action
);
6090 get_jump_space_head ();
6091 /* Copy the value of GDB_JUMP_PAD_HEAD to command buffer, so that
6092 agent can use jump pad from it. */
6093 if (tpoint
->type
== fast_tracepoint
)
6095 memcpy (p
, &gdb_jump_pad_head
, 8);
6099 ret
= run_inferior_command (buf
, (int) (ptrdiff_t) (p
- buf
));
6103 if (strncmp (buf
, "OK", 2) != 0)
6106 /* The value of tracepoint's target address is stored in BUF. */
6107 memcpy (&tpoint
->obj_addr_on_target
,
6108 &buf
[IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET
], 8);
6110 if (tpoint
->type
== fast_tracepoint
)
6113 = (unsigned char *) &buf
[IPA_PROTO_FAST_TRACE_FJUMP_INSN
];
6116 trace_debug ("agent: read from cmd_buf 0x%x 0x%x\n",
6117 (unsigned int) tpoint
->obj_addr_on_target
,
6118 (unsigned int) gdb_jump_pad_head
);
6120 memcpy (&gdb_jump_pad_head
, &buf
[IPA_PROTO_FAST_TRACE_JUMP_PAD
], 8);
6122 /* This has been done in agent. We should also set up record for it. */
6123 memcpy (&fjump_size
, &buf
[IPA_PROTO_FAST_TRACE_FJUMP_SIZE
], 4);
6126 = set_fast_tracepoint_jump (tpoint
->address
, insn
, fjump_size
);
6133 download_tracepoint (struct tracepoint
*tpoint
)
6135 struct tracepoint
*tp
, *tp_prev
;
6137 if (tpoint
->type
!= fast_tracepoint
6138 && tpoint
->type
!= static_tracepoint
)
6141 download_tracepoint_1 (tpoint
);
6143 /* Find the previous entry of TPOINT, which is fast tracepoint or
6144 static tracepoint. */
6146 for (tp
= tracepoints
; tp
!= tpoint
; tp
= tp
->next
)
6148 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
6154 CORE_ADDR tp_prev_target_next_addr
;
6156 /* Insert TPOINT after TP_PREV in IPA. */
6157 if (read_inferior_data_pointer (tp_prev
->obj_addr_on_target
6158 + offsetof (struct tracepoint
, next
),
6159 &tp_prev_target_next_addr
))
6160 fatal ("error reading `tp_prev->next'");
6162 /* tpoint->next = tp_prev->next */
6163 write_inferior_data_ptr (tpoint
->obj_addr_on_target
6164 + offsetof (struct tracepoint
, next
),
6165 tp_prev_target_next_addr
);
6166 /* tp_prev->next = tpoint */
6167 write_inferior_data_ptr (tp_prev
->obj_addr_on_target
6168 + offsetof (struct tracepoint
, next
),
6169 tpoint
->obj_addr_on_target
);
6172 /* First object in list, set the head pointer in the
6174 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
,
6175 tpoint
->obj_addr_on_target
);
6180 download_trace_state_variables (void)
6182 CORE_ADDR ptr
= 0, prev_ptr
= 0;
6183 struct trace_state_variable
*tsv
;
6185 /* Start out empty. */
6186 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
, 0);
6188 for (tsv
= trace_state_variables
; tsv
!= NULL
; tsv
= tsv
->next
)
6190 struct trace_state_variable target_tsv
;
6192 /* TSV's with a getter have been initialized equally in both the
6193 inferior and GDBserver. Skip them. */
6194 if (tsv
->getter
!= NULL
)
6200 ptr
= target_malloc (sizeof (*tsv
));
6202 if (tsv
== trace_state_variables
)
6204 /* First object in list, set the head pointer in the
6207 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
,
6212 write_inferior_data_ptr (prev_ptr
6213 + offsetof (struct trace_state_variable
,
6218 /* Write the whole object. We'll fix up its pointers in a bit.
6219 Assume no next, fixup when needed. */
6220 target_tsv
.next
= NULL
;
6222 write_inferior_memory (ptr
, (unsigned char *) &target_tsv
,
6223 sizeof (target_tsv
));
6225 if (tsv
->name
!= NULL
)
6227 size_t size
= strlen (tsv
->name
) + 1;
6228 CORE_ADDR name_addr
= target_malloc (size
);
6229 write_inferior_memory (name_addr
,
6230 (unsigned char *) tsv
->name
, size
);
6231 write_inferior_data_ptr (ptr
6232 + offsetof (struct trace_state_variable
,
6237 if (tsv
->getter
!= NULL
)
6239 fatal ("what to do with these?");
6245 /* Fixup the next pointer in the last item in the list. */
6246 write_inferior_data_ptr (prev_ptr
6247 + offsetof (struct trace_state_variable
,
6252 /* Upload complete trace frames out of the IP Agent's trace buffer
6253 into GDBserver's trace buffer. This always uploads either all or
6254 no trace frames. This is the counter part of
6255 `trace_alloc_trace_buffer'. See its description of the atomic
6256 synching mechanism. */
6259 upload_fast_traceframes (void)
6261 unsigned int ipa_traceframe_read_count
, ipa_traceframe_write_count
;
6262 unsigned int ipa_traceframe_read_count_racy
, ipa_traceframe_write_count_racy
;
6264 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
6265 unsigned int curr_tbctrl_idx
;
6266 unsigned int ipa_trace_buffer_ctrl_curr
;
6267 unsigned int ipa_trace_buffer_ctrl_curr_old
;
6268 CORE_ADDR ipa_trace_buffer_ctrl_addr
;
6269 struct breakpoint
*about_to_request_buffer_space_bkpt
;
6270 CORE_ADDR ipa_trace_buffer_lo
;
6271 CORE_ADDR ipa_trace_buffer_hi
;
6273 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6274 &ipa_traceframe_read_count_racy
))
6276 /* This will happen in most targets if the current thread is
6281 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6282 &ipa_traceframe_write_count_racy
))
6285 trace_debug ("ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6286 ipa_traceframe_write_count_racy
6287 - ipa_traceframe_read_count_racy
,
6288 ipa_traceframe_write_count_racy
,
6289 ipa_traceframe_read_count_racy
);
6291 if (ipa_traceframe_write_count_racy
== ipa_traceframe_read_count_racy
)
6294 about_to_request_buffer_space_bkpt
6295 = set_breakpoint_at (ipa_sym_addrs
.addr_about_to_request_buffer_space
,
6298 if (read_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6299 &ipa_trace_buffer_ctrl_curr
))
6302 ipa_trace_buffer_ctrl_curr_old
= ipa_trace_buffer_ctrl_curr
;
6304 curr_tbctrl_idx
= ipa_trace_buffer_ctrl_curr
& ~GDBSERVER_FLUSH_COUNT_MASK
;
6307 unsigned int prev
, counter
;
6309 /* Update the token, with new counters, and the GDBserver stamp
6310 bit. Alway reuse the current TBC index. */
6311 prev
= ipa_trace_buffer_ctrl_curr
& GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6312 counter
= (prev
+ 0x100) & GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6314 ipa_trace_buffer_ctrl_curr
= (GDBSERVER_UPDATED_FLUSH_COUNT_BIT
6320 if (write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6321 ipa_trace_buffer_ctrl_curr
))
6324 trace_debug ("Lib: Committed %08x -> %08x",
6325 ipa_trace_buffer_ctrl_curr_old
,
6326 ipa_trace_buffer_ctrl_curr
);
6328 /* Re-read these, now that we've installed the
6329 `about_to_request_buffer_space' breakpoint/lock. A thread could
6330 have finished a traceframe between the last read of these
6331 counters and setting the breakpoint above. If we start
6332 uploading, we never want to leave this function with
6333 traceframe_read_count != 0, otherwise, GDBserver could end up
6334 incrementing the counter tokens more than once (due to event loop
6335 nesting), which would break the IP agent's "effective" detection
6336 (see trace_alloc_trace_buffer). */
6337 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6338 &ipa_traceframe_read_count
))
6340 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6341 &ipa_traceframe_write_count
))
6346 trace_debug ("ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6347 ipa_traceframe_write_count
- ipa_traceframe_read_count
,
6348 ipa_traceframe_write_count
, ipa_traceframe_read_count
);
6350 if (ipa_traceframe_write_count
!= ipa_traceframe_write_count_racy
6351 || ipa_traceframe_read_count
!= ipa_traceframe_read_count_racy
)
6352 trace_debug ("note that ipa_traceframe_count's parts changed");
6355 /* Get the address of the current TBC object (the IP agent has an
6356 array of 3 such objects). The index is stored in the TBC
6358 ipa_trace_buffer_ctrl_addr
= ipa_sym_addrs
.addr_trace_buffer_ctrl
;
6359 ipa_trace_buffer_ctrl_addr
6360 += sizeof (struct ipa_trace_buffer_control
) * curr_tbctrl_idx
;
6362 if (read_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6363 (unsigned char *) &ipa_trace_buffer_ctrl
,
6364 sizeof (struct ipa_trace_buffer_control
)))
6367 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
6368 &ipa_trace_buffer_lo
))
6370 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
6371 &ipa_trace_buffer_hi
))
6374 /* Offsets are easier to grok for debugging than raw addresses,
6375 especially for the small trace buffer sizes that are useful for
6377 trace_debug ("Lib: Trace buffer [%d] start=%d free=%d "
6378 "endfree=%d wrap=%d hi=%d",
6380 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6381 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6382 (int) (ipa_trace_buffer_ctrl
.end_free
- ipa_trace_buffer_lo
),
6383 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6384 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6386 /* Note that the IPA's buffer is always circular. */
6388 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6390 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6391 ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6393 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6394 (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6395 - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6396 ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6399 tf
= IPA_FIRST_TRACEFRAME ();
6401 while (ipa_traceframe_write_count
- ipa_traceframe_read_count
)
6403 struct tracepoint
*tpoint
;
6404 struct traceframe
*tframe
;
6405 unsigned char *block
;
6406 struct traceframe ipa_tframe
;
6408 if (read_inferior_memory (tf
, (unsigned char *) &ipa_tframe
,
6409 offsetof (struct traceframe
, data
)))
6410 error ("Uploading: couldn't read traceframe at %s\n", paddress (tf
));
6412 if (ipa_tframe
.tpnum
== 0)
6413 fatal ("Uploading: No (more) fast traceframes, but "
6414 "ipa_traceframe_count == %u??\n",
6415 ipa_traceframe_write_count
- ipa_traceframe_read_count
);
6417 /* Note that this will be incorrect for multi-location
6419 tpoint
= find_next_tracepoint_by_number (NULL
, ipa_tframe
.tpnum
);
6421 tframe
= add_traceframe (tpoint
);
6424 trace_buffer_is_full
= 1;
6425 trace_debug ("Uploading: trace buffer is full");
6429 /* Copy the whole set of blocks in one go for now. FIXME:
6430 split this in smaller blocks. */
6431 block
= add_traceframe_block (tframe
, tpoint
,
6432 ipa_tframe
.data_size
);
6435 if (read_inferior_memory (tf
6436 + offsetof (struct traceframe
, data
),
6437 block
, ipa_tframe
.data_size
))
6438 error ("Uploading: Couldn't read traceframe data at %s\n",
6439 paddress (tf
+ offsetof (struct traceframe
, data
)));
6442 trace_debug ("Uploading: traceframe didn't fit");
6443 finish_traceframe (tframe
);
6446 tf
= IPA_NEXT_TRACEFRAME (tf
, &ipa_tframe
);
6448 /* If we freed the traceframe that wrapped around, go back
6449 to the non-wrap case. */
6450 if (tf
< ipa_trace_buffer_ctrl
.start
)
6452 trace_debug ("Lib: Discarding past the wraparound");
6453 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6455 ipa_trace_buffer_ctrl
.start
= tf
;
6456 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_ctrl
.start
;
6457 ++ipa_traceframe_read_count
;
6459 if (ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.free
6460 && ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.end_free
)
6462 trace_debug ("Lib: buffer is fully empty. "
6463 "Trace buffer [%d] start=%d free=%d endfree=%d",
6465 (int) (ipa_trace_buffer_ctrl
.start
6466 - ipa_trace_buffer_lo
),
6467 (int) (ipa_trace_buffer_ctrl
.free
6468 - ipa_trace_buffer_lo
),
6469 (int) (ipa_trace_buffer_ctrl
.end_free
6470 - ipa_trace_buffer_lo
));
6472 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
6473 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
6474 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
6475 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6478 trace_debug ("Uploaded a traceframe\n"
6479 "Lib: Trace buffer [%d] start=%d free=%d "
6480 "endfree=%d wrap=%d hi=%d",
6482 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6483 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6484 (int) (ipa_trace_buffer_ctrl
.end_free
6485 - ipa_trace_buffer_lo
),
6486 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6487 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6490 if (write_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6491 (unsigned char *) &ipa_trace_buffer_ctrl
,
6492 sizeof (struct ipa_trace_buffer_control
)))
6495 write_inferior_integer (ipa_sym_addrs
.addr_traceframe_read_count
,
6496 ipa_traceframe_read_count
);
6498 trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx
);
6501 cancel_breakpoints ();
6503 delete_breakpoint (about_to_request_buffer_space_bkpt
);
6504 about_to_request_buffer_space_bkpt
= NULL
;
6508 if (trace_buffer_is_full
)
6513 #ifdef IN_PROCESS_AGENT
6515 IP_AGENT_EXPORT
int ust_loaded
;
6516 IP_AGENT_EXPORT
char cmd_buf
[IPA_CMD_BUF_SIZE
];
6520 /* Static tracepoints. */
6522 /* UST puts a "struct tracepoint" in the global namespace, which
6523 conflicts with our tracepoint. Arguably, being a library, it
6524 shouldn't take ownership of such a generic name. We work around it
6526 #define tracepoint ust_tracepoint
6527 #include <ust/ust.h>
6530 extern int serialize_to_text (char *outbuf
, int bufsize
,
6531 const char *fmt
, va_list ap
);
6533 #define GDB_PROBE_NAME "gdb"
6535 /* We dynamically search for the UST symbols instead of linking them
6536 in. This lets the user decide if the application uses static
6537 tracepoints, instead of always pulling libust.so in. This vector
6538 holds pointers to all functions we care about. */
6542 int (*serialize_to_text
) (char *outbuf
, int bufsize
,
6543 const char *fmt
, va_list ap
);
6545 int (*ltt_probe_register
) (struct ltt_available_probe
*pdata
);
6546 int (*ltt_probe_unregister
) (struct ltt_available_probe
*pdata
);
6548 int (*ltt_marker_connect
) (const char *channel
, const char *mname
,
6550 int (*ltt_marker_disconnect
) (const char *channel
, const char *mname
,
6553 void (*marker_iter_start
) (struct marker_iter
*iter
);
6554 void (*marker_iter_next
) (struct marker_iter
*iter
);
6555 void (*marker_iter_stop
) (struct marker_iter
*iter
);
6556 void (*marker_iter_reset
) (struct marker_iter
*iter
);
6561 /* Cast through typeof to catch incompatible API changes. Since UST
6562 only builds with gcc, we can freely use gcc extensions here
6564 #define GET_UST_SYM(SYM) \
6567 if (ust_ops.SYM == NULL) \
6568 ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6569 if (ust_ops.SYM == NULL) \
6573 #define USTF(SYM) ust_ops.SYM
6575 /* Get pointers to all libust.so functions we care about. */
6580 GET_UST_SYM (serialize_to_text
);
6582 GET_UST_SYM (ltt_probe_register
);
6583 GET_UST_SYM (ltt_probe_unregister
);
6584 GET_UST_SYM (ltt_marker_connect
);
6585 GET_UST_SYM (ltt_marker_disconnect
);
6587 GET_UST_SYM (marker_iter_start
);
6588 GET_UST_SYM (marker_iter_next
);
6589 GET_UST_SYM (marker_iter_stop
);
6590 GET_UST_SYM (marker_iter_reset
);
6596 /* Given an UST marker, return the matching gdb static tracepoint.
6597 The match is done by address. */
6599 static struct tracepoint
*
6600 ust_marker_to_static_tracepoint (const struct marker
*mdata
)
6602 struct tracepoint
*tpoint
;
6604 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
6606 if (tpoint
->type
!= static_tracepoint
)
6609 if (tpoint
->address
== (uintptr_t) mdata
->location
)
6616 /* The probe function we install on lttng/ust markers. Whenever a
6617 probed ust marker is hit, this function is called. This is similar
6618 to gdb_collect, only for static tracepoints, instead of fast
6622 gdb_probe (const struct marker
*mdata
, void *probe_private
,
6623 struct registers
*regs
, void *call_private
,
6624 const char *fmt
, va_list *args
)
6626 struct tracepoint
*tpoint
;
6627 struct static_tracepoint_ctx ctx
;
6629 /* Don't do anything until the trace run is completely set up. */
6632 trace_debug ("gdb_probe: not tracing\n");
6636 ctx
.base
.type
= static_tracepoint
;
6637 ctx
.regcache_initted
= 0;
6642 /* Wrap the regblock in a register cache (in the stack, we don't
6643 want to malloc here). */
6644 ctx
.regspace
= alloca (ipa_tdesc
->registers_size
);
6645 if (ctx
.regspace
== NULL
)
6647 trace_debug ("Trace buffer block allocation failed, skipping");
6651 tpoint
= ust_marker_to_static_tracepoint (mdata
);
6654 trace_debug ("gdb_probe: marker not known: "
6655 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6656 mdata
->location
, mdata
->channel
,
6657 mdata
->name
, mdata
->format
);
6661 if (!tpoint
->enabled
)
6663 trace_debug ("gdb_probe: tracepoint disabled");
6667 ctx
.tpoint
= tpoint
;
6669 trace_debug ("gdb_probe: collecting marker: "
6670 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6671 mdata
->location
, mdata
->channel
,
6672 mdata
->name
, mdata
->format
);
6674 /* Test the condition if present, and collect if true. */
6675 if (tpoint
->cond
== NULL
6676 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6679 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6680 tpoint
->address
, tpoint
);
6682 if (stopping_tracepoint
6683 || trace_buffer_is_full
6684 || expr_eval_result
!= expr_eval_no_error
)
6689 /* If there was a condition and it evaluated to false, the only
6690 way we would stop tracing is if there was an error during
6691 condition expression evaluation. */
6692 if (expr_eval_result
!= expr_eval_no_error
)
6697 /* Called if the gdb static tracepoint requested collecting "$_sdata",
6698 static tracepoint string data. This is a string passed to the
6699 tracing library by the user, at the time of the tracepoint marker
6700 call. E.g., in the UST marker call:
6702 trace_mark (ust, bar33, "str %s", "FOOBAZ");
6704 the collected data is "str FOOBAZ".
6708 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
6709 struct traceframe
*tframe
)
6711 struct static_tracepoint_ctx
*umd
= (struct static_tracepoint_ctx
*) ctx
;
6712 unsigned char *bufspace
;
6715 unsigned short blocklen
;
6719 trace_debug ("Wanted to collect static trace data, "
6720 "but there's no static trace data");
6724 va_copy (copy
, *umd
->args
);
6725 size
= USTF(serialize_to_text
) (NULL
, 0, umd
->fmt
, copy
);
6728 trace_debug ("Want to collect ust data");
6730 /* 'S' + size + string */
6731 bufspace
= add_traceframe_block (tframe
, umd
->tpoint
,
6732 1 + sizeof (blocklen
) + size
+ 1);
6733 if (bufspace
== NULL
)
6735 trace_debug ("Trace buffer block allocation failed, skipping");
6739 /* Identify a static trace data block. */
6742 blocklen
= size
+ 1;
6743 memcpy (bufspace
+ 1, &blocklen
, sizeof (blocklen
));
6745 va_copy (copy
, *umd
->args
);
6746 USTF(serialize_to_text
) ((char *) bufspace
+ 1 + sizeof (blocklen
),
6747 size
+ 1, umd
->fmt
, copy
);
6750 trace_debug ("Storing static tracepoint data in regblock: %s",
6751 bufspace
+ 1 + sizeof (blocklen
));
6754 /* The probe to register with lttng/ust. */
6755 static struct ltt_available_probe gdb_ust_probe
=
6762 #endif /* HAVE_UST */
6763 #endif /* IN_PROCESS_AGENT */
6765 #ifndef IN_PROCESS_AGENT
6767 /* Ask the in-process agent to run a command. Since we don't want to
6768 have to handle the IPA hitting breakpoints while running the
6769 command, we pause all threads, remove all breakpoints, and then set
6770 the helper thread re-running. We communicate with the helper
6771 thread by means of direct memory xfering, and a socket for
6775 run_inferior_command (char *cmd
, int len
)
6778 int pid
= ptid_get_pid (current_ptid
);
6780 trace_debug ("run_inferior_command: running: %s", cmd
);
6783 uninsert_all_breakpoints ();
6785 err
= agent_run_command (pid
, (const char *) cmd
, len
);
6787 reinsert_all_breakpoints ();
6793 #else /* !IN_PROCESS_AGENT */
6795 #include <sys/socket.h>
6798 #ifndef UNIX_PATH_MAX
6799 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6802 /* Where we put the socked used for synchronization. */
6803 #define SOCK_DIR P_tmpdir
6805 /* Thread ID of the helper thread. GDBserver reads this to know which
6806 is the help thread. This is an LWP id on Linux. */
6807 int helper_thread_id
;
6810 init_named_socket (const char *name
)
6813 struct sockaddr_un addr
;
6815 result
= fd
= socket (PF_UNIX
, SOCK_STREAM
, 0);
6818 warning ("socket creation failed: %s", strerror (errno
));
6822 addr
.sun_family
= AF_UNIX
;
6824 strncpy (addr
.sun_path
, name
, UNIX_PATH_MAX
);
6825 addr
.sun_path
[UNIX_PATH_MAX
- 1] = '\0';
6827 result
= access (name
, F_OK
);
6831 result
= unlink (name
);
6834 warning ("unlink failed: %s", strerror (errno
));
6838 warning ("socket %s already exists; overwriting", name
);
6841 result
= bind (fd
, (struct sockaddr
*) &addr
, sizeof (addr
));
6844 warning ("bind failed: %s", strerror (errno
));
6849 result
= listen (fd
, 1);
6852 warning ("listen: %s", strerror (errno
));
6860 static char agent_socket_name
[UNIX_PATH_MAX
];
6863 gdb_agent_socket_init (void)
6867 result
= xsnprintf (agent_socket_name
, UNIX_PATH_MAX
, "%s/gdb_ust%d",
6868 SOCK_DIR
, getpid ());
6869 if (result
>= UNIX_PATH_MAX
)
6871 trace_debug ("string overflow allocating socket name");
6875 fd
= init_named_socket (agent_socket_name
);
6877 warning ("Error initializing named socket (%s) for communication with the "
6878 "ust helper thread. Check that directory exists and that it "
6879 "is writable.", agent_socket_name
);
6886 /* The next marker to be returned on a qTsSTM command. */
6887 static const struct marker
*next_st
;
6889 /* Returns the first known marker. */
6894 struct marker_iter iter
;
6896 USTF(marker_iter_reset
) (&iter
);
6897 USTF(marker_iter_start
) (&iter
);
6902 /* Returns the marker following M. */
6904 const struct marker
*
6905 next_marker (const struct marker
*m
)
6907 struct marker_iter iter
;
6909 USTF(marker_iter_reset
) (&iter
);
6910 USTF(marker_iter_start
) (&iter
);
6912 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
6914 if (iter
.marker
== m
)
6916 USTF(marker_iter_next
) (&iter
);
6924 /* Return an hexstr version of the STR C string, fit for sending to
6928 cstr_to_hexstr (const char *str
)
6930 int len
= strlen (str
);
6931 char *hexstr
= xmalloc (len
* 2 + 1);
6932 convert_int_to_ascii ((gdb_byte
*) str
, hexstr
, len
);
6936 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
6940 response_ust_marker (char *packet
, const struct marker
*st
)
6942 char *strid
, *format
, *tmp
;
6944 next_st
= next_marker (st
);
6946 tmp
= xmalloc (strlen (st
->channel
) + 1 +
6947 strlen (st
->name
) + 1);
6948 sprintf (tmp
, "%s/%s", st
->channel
, st
->name
);
6950 strid
= cstr_to_hexstr (tmp
);
6953 format
= cstr_to_hexstr (st
->format
);
6955 sprintf (packet
, "m%s:%s:%s",
6956 paddress ((uintptr_t) st
->location
),
6964 /* Return the first static tracepoint, and initialize the state
6965 machine that will iterate through all the static tracepoints. */
6968 cmd_qtfstm (char *packet
)
6970 trace_debug ("Returning first trace state variable definition");
6972 if (first_marker ())
6973 response_ust_marker (packet
, first_marker ());
6975 strcpy (packet
, "l");
6978 /* Return additional trace state variable definitions. */
6981 cmd_qtsstm (char *packet
)
6983 trace_debug ("Returning static tracepoint");
6986 response_ust_marker (packet
, next_st
);
6988 strcpy (packet
, "l");
6991 /* Disconnect the GDB probe from a marker at a given address. */
6994 unprobe_marker_at (char *packet
)
6998 struct marker_iter iter
;
7000 p
+= sizeof ("unprobe_marker_at:") - 1;
7002 p
= unpack_varlen_hex (p
, &address
);
7004 USTF(marker_iter_reset
) (&iter
);
7005 USTF(marker_iter_start
) (&iter
);
7006 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
7007 if ((uintptr_t ) iter
.marker
->location
== address
)
7011 result
= USTF(ltt_marker_disconnect
) (iter
.marker
->channel
,
7015 warning ("could not disable marker %s/%s",
7016 iter
.marker
->channel
, iter
.marker
->name
);
7021 /* Connect the GDB probe to a marker at a given address. */
7024 probe_marker_at (char *packet
)
7028 struct marker_iter iter
;
7031 p
+= sizeof ("probe_marker_at:") - 1;
7033 p
= unpack_varlen_hex (p
, &address
);
7035 USTF(marker_iter_reset
) (&iter
);
7037 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7039 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7040 if ((uintptr_t ) m
->location
== address
)
7044 trace_debug ("found marker for address. "
7045 "ltt_marker_connect (marker = %s/%s)",
7046 m
->channel
, m
->name
);
7048 result
= USTF(ltt_marker_connect
) (m
->channel
, m
->name
,
7050 if (result
&& result
!= -EEXIST
)
7051 trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
7052 m
->channel
, m
->name
, -result
);
7056 sprintf (packet
, "E.could not connect marker: channel=%s, name=%s",
7057 m
->channel
, m
->name
);
7061 strcpy (packet
, "OK");
7065 sprintf (packet
, "E.no marker found at 0x%s", paddress (address
));
7070 cmd_qtstmat (char *packet
)
7074 struct marker_iter iter
;
7077 p
+= sizeof ("qTSTMat:") - 1;
7079 p
= unpack_varlen_hex (p
, &address
);
7081 USTF(marker_iter_reset
) (&iter
);
7083 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7085 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7086 if ((uintptr_t ) m
->location
== address
)
7088 response_ust_marker (packet
, m
);
7092 strcpy (packet
, "l");
7102 USTF(ltt_probe_register
) (&gdb_ust_probe
);
7105 #endif /* HAVE_UST */
7107 #include <sys/syscall.h>
7111 gdb_agent_remove_socket (void)
7113 unlink (agent_socket_name
);
7116 /* Helper thread of agent. */
7119 gdb_agent_helper_thread (void *arg
)
7123 atexit (gdb_agent_remove_socket
);
7127 listen_fd
= gdb_agent_socket_init ();
7129 if (helper_thread_id
== 0)
7130 helper_thread_id
= syscall (SYS_gettid
);
7132 if (listen_fd
== -1)
7134 warning ("could not create sync socket\n");
7141 struct sockaddr_un sockaddr
;
7147 tmp
= sizeof (sockaddr
);
7151 fd
= accept (listen_fd
, &sockaddr
, &tmp
);
7153 /* It seems an ERESTARTSYS can escape out of accept. */
7154 while (fd
== -512 || (fd
== -1 && errno
== EINTR
));
7158 warning ("Accept returned %d, error: %s\n",
7159 fd
, strerror (errno
));
7165 ret
= read (fd
, buf
, 1);
7166 } while (ret
== -1 && errno
== EINTR
);
7170 warning ("reading socket (fd=%d) failed with %s",
7171 fd
, strerror (errno
));
7178 if (strncmp ("close", cmd_buf
, 5) == 0)
7183 else if (strcmp ("qTfSTM", cmd_buf
) == 0)
7185 cmd_qtfstm (cmd_buf
);
7187 else if (strcmp ("qTsSTM", cmd_buf
) == 0)
7189 cmd_qtsstm (cmd_buf
);
7191 else if (strncmp ("unprobe_marker_at:",
7193 sizeof ("unprobe_marker_at:") - 1) == 0)
7195 unprobe_marker_at (cmd_buf
);
7197 else if (strncmp ("probe_marker_at:",
7199 sizeof ("probe_marker_at:") - 1) == 0)
7201 probe_marker_at (cmd_buf
);
7203 else if (strncmp ("qTSTMat:",
7205 sizeof ("qTSTMat:") - 1) == 0)
7207 cmd_qtstmat (cmd_buf
);
7209 #endif /* HAVE_UST */
7212 /* Fix compiler's warning: ignoring return value of 'write'. */
7213 ret
= write (fd
, buf
, 1);
7219 unlink (agent_socket_name
);
7221 /* Sleep endlessly to wait the whole inferior stops. This
7222 thread can not exit because GDB or GDBserver may still need
7223 'current_inferior' (representing this thread) to access
7224 inferior memory. Otherwise, this thread exits earlier than
7225 other threads, and 'current_inferior' is set to NULL. */
7236 #include <pthread.h>
7238 IP_AGENT_EXPORT
int gdb_agent_capability
= AGENT_CAPA_STATIC_TRACE
;
7241 gdb_agent_init (void)
7248 /* We want the helper thread to be as transparent as possible, so
7249 have it inherit an all-signals-blocked mask. */
7251 sigfillset (&new_mask
);
7252 res
= pthread_sigmask (SIG_SETMASK
, &new_mask
, &orig_mask
);
7254 fatal ("pthread_sigmask (1) failed: %s", strerror (res
));
7256 res
= pthread_create (&thread
,
7258 gdb_agent_helper_thread
,
7261 res
= pthread_sigmask (SIG_SETMASK
, &orig_mask
, NULL
);
7263 fatal ("pthread_sigmask (2) failed: %s", strerror (res
));
7265 while (helper_thread_id
== 0)
7273 #include <sys/mman.h>
7276 IP_AGENT_EXPORT
char *gdb_tp_heap_buffer
;
7277 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer
;
7278 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer_end
;
7279 IP_AGENT_EXPORT
char *gdb_trampoline_buffer
;
7280 IP_AGENT_EXPORT
char *gdb_trampoline_buffer_end
;
7281 IP_AGENT_EXPORT
char *gdb_trampoline_buffer_error
;
7283 /* Record the result of getting buffer space for fast tracepoint
7284 trampolines. Any error message is copied, since caller may not be
7285 using persistent storage. */
7288 set_trampoline_buffer_space (CORE_ADDR begin
, CORE_ADDR end
, char *errmsg
)
7290 gdb_trampoline_buffer
= (char *) (uintptr_t) begin
;
7291 gdb_trampoline_buffer_end
= (char *) (uintptr_t) end
;
7293 strncpy (gdb_trampoline_buffer_error
, errmsg
, 99);
7295 strcpy (gdb_trampoline_buffer_error
, "no buffer passed");
7298 static void __attribute__ ((constructor
))
7299 initialize_tracepoint_ftlib (void)
7301 initialize_tracepoint ();
7306 #endif /* IN_PROCESS_AGENT */
7308 /* Return a timestamp, expressed as microseconds of the usual Unix
7309 time. (As the result is a 64-bit number, it will not overflow any
7313 get_timestamp (void)
7317 if (gettimeofday (&tv
, 0) != 0)
7320 return (LONGEST
) tv
.tv_sec
* 1000000 + tv
.tv_usec
;
7324 initialize_tracepoint (void)
7326 /* Start with the default size. */
7327 init_trace_buffer (DEFAULT_TRACE_BUFFER_SIZE
);
7329 /* Wire trace state variable 1 to be the timestamp. This will be
7330 uploaded to GDB upon connection and become one of its trace state
7331 variables. (In case you're wondering, if GDB already has a trace
7332 variable numbered 1, it will be renumbered.) */
7333 create_trace_state_variable (1, 0);
7334 set_trace_state_variable_name (1, "trace_timestamp");
7335 set_trace_state_variable_getter (1, get_timestamp
);
7337 #ifdef IN_PROCESS_AGENT
7342 pagesize
= sysconf (_SC_PAGE_SIZE
);
7346 gdb_tp_heap_buffer
= xmalloc (5 * 1024 * 1024);
7348 #define SCRATCH_BUFFER_NPAGES 20
7350 /* Allocate scratch buffer aligned on a page boundary, at a low
7351 address (close to the main executable's code). */
7352 for (addr
= pagesize
; addr
!= 0; addr
+= pagesize
)
7354 gdb_jump_pad_buffer
= mmap ((void *) addr
, pagesize
* SCRATCH_BUFFER_NPAGES
,
7355 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
7356 MAP_PRIVATE
| MAP_ANONYMOUS
| MAP_FIXED
,
7358 if (gdb_jump_pad_buffer
!= MAP_FAILED
)
7364 initialize_tracepoint: mmap'ing jump pad buffer failed with %s",
7367 gdb_jump_pad_buffer_end
= gdb_jump_pad_buffer
+ pagesize
* SCRATCH_BUFFER_NPAGES
;
7370 gdb_trampoline_buffer
= gdb_trampoline_buffer_end
= 0;
7372 /* It's not a fatal error for something to go wrong with trampoline
7373 buffer setup, but it can be mysterious, so create a channel to
7374 report back on what went wrong, using a fixed size since we may
7375 not be able to allocate space later when the problem occurs. */
7376 gdb_trampoline_buffer_error
= xmalloc (IPA_BUFSIZ
);
7378 strcpy (gdb_trampoline_buffer_error
, "No errors reported");
7380 initialize_low_tracepoint ();