1 /* Tracepoint code for remote server for GDB.
2 Copyright (C) 2009-2015 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"
28 #include "gdb_sys_time.h"
33 #define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
35 /* This file is built for both GDBserver, and the in-process
36 agent (IPA), a shared library that includes a tracing agent that is
37 loaded by the inferior to support fast tracepoints. Fast
38 tracepoints (or more accurately, jump based tracepoints) are
39 implemented by patching the tracepoint location with a jump into a
40 small trampoline function whose job is to save the register state,
41 call the in-process tracing agent, and then execute the original
42 instruction that was under the tracepoint jump (possibly adjusted,
43 if PC-relative, or some such).
45 The current synchronization design is pull based. That means,
46 GDBserver does most of the work, by peeking/poking at the inferior
47 agent's memory directly for downloading tracepoint and associated
48 objects, and for uploading trace frames. Whenever the IPA needs
49 something from GDBserver (trace buffer is full, tracing stopped for
50 some reason, etc.) the IPA calls a corresponding hook function
51 where GDBserver has placed a breakpoint.
53 Each of the agents has its own trace buffer. When browsing the
54 trace frames built from slow and fast tracepoints from GDB (tfind
55 mode), there's no guarantee the user is seeing the trace frames in
56 strict chronological creation order, although, GDBserver tries to
57 keep the order relatively reasonable, by syncing the trace buffers
62 #ifdef IN_PROCESS_AGENT
64 static void trace_vdebug (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
67 trace_vdebug (const char *fmt
, ...)
73 vsprintf (buf
, fmt
, ap
);
74 fprintf (stderr
, PROG
"/tracepoint: %s\n", buf
);
78 #define trace_debug_1(level, fmt, args...) \
80 if (level <= debug_threads) \
81 trace_vdebug ((fmt), ##args); \
86 #define trace_debug_1(level, fmt, args...) \
88 if (level <= debug_threads) \
90 debug_printf ((fmt), ##args); \
91 debug_printf ("\n"); \
97 #define trace_debug(FMT, args...) \
98 trace_debug_1 (1, FMT, ##args)
100 /* Prefix exported symbols, for good citizenship. All the symbols
101 that need exporting are defined in this module. Note that all
102 these symbols must be tagged with IP_AGENT_EXPORT_*. */
103 #ifdef IN_PROCESS_AGENT
104 # define gdb_tp_heap_buffer IPA_SYM_EXPORTED_NAME (gdb_tp_heap_buffer)
105 # define gdb_jump_pad_buffer IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer)
106 # define gdb_jump_pad_buffer_end IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer_end)
107 # define gdb_trampoline_buffer IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer)
108 # define gdb_trampoline_buffer_end IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_end)
109 # define gdb_trampoline_buffer_error IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_error)
110 # define collecting IPA_SYM_EXPORTED_NAME (collecting)
111 # define gdb_collect IPA_SYM_EXPORTED_NAME (gdb_collect)
112 # define stop_tracing IPA_SYM_EXPORTED_NAME (stop_tracing)
113 # define flush_trace_buffer IPA_SYM_EXPORTED_NAME (flush_trace_buffer)
114 # define about_to_request_buffer_space IPA_SYM_EXPORTED_NAME (about_to_request_buffer_space)
115 # define trace_buffer_is_full IPA_SYM_EXPORTED_NAME (trace_buffer_is_full)
116 # define stopping_tracepoint IPA_SYM_EXPORTED_NAME (stopping_tracepoint)
117 # define expr_eval_result IPA_SYM_EXPORTED_NAME (expr_eval_result)
118 # define error_tracepoint IPA_SYM_EXPORTED_NAME (error_tracepoint)
119 # define tracepoints IPA_SYM_EXPORTED_NAME (tracepoints)
120 # define tracing IPA_SYM_EXPORTED_NAME (tracing)
121 # define trace_buffer_ctrl IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl)
122 # define trace_buffer_ctrl_curr IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl_curr)
123 # define trace_buffer_lo IPA_SYM_EXPORTED_NAME (trace_buffer_lo)
124 # define trace_buffer_hi IPA_SYM_EXPORTED_NAME (trace_buffer_hi)
125 # define traceframe_read_count IPA_SYM_EXPORTED_NAME (traceframe_read_count)
126 # define traceframe_write_count IPA_SYM_EXPORTED_NAME (traceframe_write_count)
127 # define traceframes_created IPA_SYM_EXPORTED_NAME (traceframes_created)
128 # define trace_state_variables IPA_SYM_EXPORTED_NAME (trace_state_variables)
129 # define get_raw_reg IPA_SYM_EXPORTED_NAME (get_raw_reg)
130 # define get_trace_state_variable_value \
131 IPA_SYM_EXPORTED_NAME (get_trace_state_variable_value)
132 # define set_trace_state_variable_value \
133 IPA_SYM_EXPORTED_NAME (set_trace_state_variable_value)
134 # define ust_loaded IPA_SYM_EXPORTED_NAME (ust_loaded)
135 # define helper_thread_id IPA_SYM_EXPORTED_NAME (helper_thread_id)
136 # define cmd_buf IPA_SYM_EXPORTED_NAME (cmd_buf)
139 #ifndef IN_PROCESS_AGENT
141 /* Addresses of in-process agent's symbols GDBserver cares about. */
143 struct ipa_sym_addresses
145 CORE_ADDR addr_gdb_tp_heap_buffer
;
146 CORE_ADDR addr_gdb_jump_pad_buffer
;
147 CORE_ADDR addr_gdb_jump_pad_buffer_end
;
148 CORE_ADDR addr_gdb_trampoline_buffer
;
149 CORE_ADDR addr_gdb_trampoline_buffer_end
;
150 CORE_ADDR addr_gdb_trampoline_buffer_error
;
151 CORE_ADDR addr_collecting
;
152 CORE_ADDR addr_gdb_collect
;
153 CORE_ADDR addr_stop_tracing
;
154 CORE_ADDR addr_flush_trace_buffer
;
155 CORE_ADDR addr_about_to_request_buffer_space
;
156 CORE_ADDR addr_trace_buffer_is_full
;
157 CORE_ADDR addr_stopping_tracepoint
;
158 CORE_ADDR addr_expr_eval_result
;
159 CORE_ADDR addr_error_tracepoint
;
160 CORE_ADDR addr_tracepoints
;
161 CORE_ADDR addr_tracing
;
162 CORE_ADDR addr_trace_buffer_ctrl
;
163 CORE_ADDR addr_trace_buffer_ctrl_curr
;
164 CORE_ADDR addr_trace_buffer_lo
;
165 CORE_ADDR addr_trace_buffer_hi
;
166 CORE_ADDR addr_traceframe_read_count
;
167 CORE_ADDR addr_traceframe_write_count
;
168 CORE_ADDR addr_traceframes_created
;
169 CORE_ADDR addr_trace_state_variables
;
170 CORE_ADDR addr_get_raw_reg
;
171 CORE_ADDR addr_get_trace_state_variable_value
;
172 CORE_ADDR addr_set_trace_state_variable_value
;
173 CORE_ADDR addr_ust_loaded
;
181 IPA_SYM(gdb_tp_heap_buffer
),
182 IPA_SYM(gdb_jump_pad_buffer
),
183 IPA_SYM(gdb_jump_pad_buffer_end
),
184 IPA_SYM(gdb_trampoline_buffer
),
185 IPA_SYM(gdb_trampoline_buffer_end
),
186 IPA_SYM(gdb_trampoline_buffer_error
),
188 IPA_SYM(gdb_collect
),
189 IPA_SYM(stop_tracing
),
190 IPA_SYM(flush_trace_buffer
),
191 IPA_SYM(about_to_request_buffer_space
),
192 IPA_SYM(trace_buffer_is_full
),
193 IPA_SYM(stopping_tracepoint
),
194 IPA_SYM(expr_eval_result
),
195 IPA_SYM(error_tracepoint
),
196 IPA_SYM(tracepoints
),
198 IPA_SYM(trace_buffer_ctrl
),
199 IPA_SYM(trace_buffer_ctrl_curr
),
200 IPA_SYM(trace_buffer_lo
),
201 IPA_SYM(trace_buffer_hi
),
202 IPA_SYM(traceframe_read_count
),
203 IPA_SYM(traceframe_write_count
),
204 IPA_SYM(traceframes_created
),
205 IPA_SYM(trace_state_variables
),
206 IPA_SYM(get_raw_reg
),
207 IPA_SYM(get_trace_state_variable_value
),
208 IPA_SYM(set_trace_state_variable_value
),
212 static struct ipa_sym_addresses ipa_sym_addrs
;
214 static int read_inferior_integer (CORE_ADDR symaddr
, int *val
);
216 /* Returns true if both the in-process agent library and the static
217 tracepoints libraries are loaded in the inferior, and agent has
218 capability on static tracepoints. */
221 in_process_agent_supports_ust (void)
225 if (!agent_loaded_p ())
227 warning ("In-process agent not loaded");
231 if (agent_capability_check (AGENT_CAPA_STATIC_TRACE
))
233 /* Agent understands static tracepoint, then check whether UST is in
234 fact loaded in the inferior. */
235 if (read_inferior_integer (ipa_sym_addrs
.addr_ust_loaded
, &loaded
))
237 warning ("Error reading ust_loaded in lib");
248 write_e_ipa_not_loaded (char *buffer
)
251 "E.In-process agent library not loaded in process. "
252 "Fast and static tracepoints unavailable.");
255 /* Write an error to BUFFER indicating that UST isn't loaded in the
259 write_e_ust_not_loaded (char *buffer
)
263 "E.UST library not loaded in process. "
264 "Static tracepoints unavailable.");
266 sprintf (buffer
, "E.GDBserver was built without static tracepoints support");
270 /* If the in-process agent library isn't loaded in the inferior, write
271 an error to BUFFER, and return 1. Otherwise, return 0. */
274 maybe_write_ipa_not_loaded (char *buffer
)
276 if (!agent_loaded_p ())
278 write_e_ipa_not_loaded (buffer
);
284 /* If the in-process agent library and the ust (static tracepoints)
285 library aren't loaded in the inferior, write an error to BUFFER,
286 and return 1. Otherwise, return 0. */
289 maybe_write_ipa_ust_not_loaded (char *buffer
)
291 if (!agent_loaded_p ())
293 write_e_ipa_not_loaded (buffer
);
296 else if (!in_process_agent_supports_ust ())
298 write_e_ust_not_loaded (buffer
);
304 /* Cache all future symbols that the tracepoints module might request.
305 We can not request symbols at arbitrary states in the remote
306 protocol, only when the client tells us that new symbols are
307 available. So when we load the in-process library, make sure to
308 check the entire list. */
311 tracepoint_look_up_symbols (void)
315 if (agent_loaded_p ())
318 for (i
= 0; i
< sizeof (symbol_list
) / sizeof (symbol_list
[0]); i
++)
321 (CORE_ADDR
*) ((char *) &ipa_sym_addrs
+ symbol_list
[i
].offset
);
323 if (look_up_one_symbol (symbol_list
[i
].name
, addrp
, 1) == 0)
326 debug_printf ("symbol `%s' not found\n", symbol_list
[i
].name
);
331 agent_look_up_symbols (NULL
);
336 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
337 of the "stop_tracing" function. When this breakpoint is hit,
338 tracing stopped in the IPA for some reason. E.g., due to
339 tracepoint reaching the pass count, hitting conditional expression
340 evaluation error, etc.
342 The IPA's trace buffer is never in circular tracing mode: instead,
343 GDBserver's is, and whenever the in-process buffer fills, it calls
344 "flush_trace_buffer", which triggers an internal breakpoint.
345 GDBserver reacts to this breakpoint by pulling the meanwhile
346 collected data. Old frames discarding is always handled on the
349 #ifdef IN_PROCESS_AGENT
351 read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
353 memcpy (myaddr
, (void *) (uintptr_t) memaddr
, len
);
357 /* Call this in the functions where GDBserver places a breakpoint, so
358 that the compiler doesn't try to be clever and skip calling the
359 function at all. This is necessary, even if we tell the compiler
360 to not inline said functions. */
362 #if defined(__GNUC__)
363 # define UNKNOWN_SIDE_EFFECTS() asm ("")
365 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
368 IP_AGENT_EXPORT_FUNC
void
371 /* GDBserver places breakpoint here. */
372 UNKNOWN_SIDE_EFFECTS();
375 IP_AGENT_EXPORT_FUNC
void
376 flush_trace_buffer (void)
378 /* GDBserver places breakpoint here. */
379 UNKNOWN_SIDE_EFFECTS();
384 #ifndef IN_PROCESS_AGENT
386 tracepoint_handler (CORE_ADDR address
)
388 trace_debug ("tracepoint_handler: tracepoint at 0x%s hit",
393 /* Breakpoint at "stop_tracing" in the inferior lib. */
394 struct breakpoint
*stop_tracing_bkpt
;
395 static int stop_tracing_handler (CORE_ADDR
);
397 /* Breakpoint at "flush_trace_buffer" in the inferior lib. */
398 struct breakpoint
*flush_trace_buffer_bkpt
;
399 static int flush_trace_buffer_handler (CORE_ADDR
);
401 static void download_trace_state_variables (void);
402 static void upload_fast_traceframes (void);
404 static int run_inferior_command (char *cmd
, int len
);
407 read_inferior_integer (CORE_ADDR symaddr
, int *val
)
409 return read_inferior_memory (symaddr
, (unsigned char *) val
,
414 static int tracepoint_send_agent (struct tracepoint
*tpoint
);
417 read_inferior_uinteger (CORE_ADDR symaddr
, unsigned int *val
)
419 return read_inferior_memory (symaddr
, (unsigned char *) val
,
424 read_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR
*val
)
426 void *pval
= (void *) (uintptr_t) val
;
429 ret
= read_inferior_memory (symaddr
, (unsigned char *) &pval
, sizeof (pval
));
430 *val
= (uintptr_t) pval
;
435 write_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR val
)
437 void *pval
= (void *) (uintptr_t) val
;
438 return write_inferior_memory (symaddr
,
439 (unsigned char *) &pval
, sizeof (pval
));
443 write_inferior_integer (CORE_ADDR symaddr
, int val
)
445 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
449 write_inferior_uinteger (CORE_ADDR symaddr
, unsigned int val
)
451 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
454 static CORE_ADDR
target_malloc (ULONGEST size
);
455 static int write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
);
457 #define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
459 memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
460 BUF += sizeof ((OBJ)->FIELD); \
465 /* Operations on various types of tracepoint actions. */
467 struct tracepoint_action
;
469 struct tracepoint_action_ops
471 /* Download tracepoint action ACTION to IPA. Return the address of action
473 CORE_ADDR (*download
) (const struct tracepoint_action
*action
);
475 /* Send ACTION to agent via command buffer started from BUFFER. Return
476 updated head of command buffer. */
477 char* (*send
) (char *buffer
, const struct tracepoint_action
*action
);
480 /* Base action. Concrete actions inherit this. */
482 struct tracepoint_action
484 #ifndef IN_PROCESS_AGENT
485 const struct tracepoint_action_ops
*ops
;
490 /* An 'M' (collect memory) action. */
491 struct collect_memory_action
493 struct tracepoint_action base
;
500 /* An 'R' (collect registers) action. */
502 struct collect_registers_action
504 struct tracepoint_action base
;
507 /* An 'X' (evaluate expression) action. */
509 struct eval_expr_action
511 struct tracepoint_action base
;
513 struct agent_expr
*expr
;
516 /* An 'L' (collect static trace data) action. */
517 struct collect_static_trace_data_action
519 struct tracepoint_action base
;
522 #ifndef IN_PROCESS_AGENT
524 m_tracepoint_action_download (const struct tracepoint_action
*action
)
526 int size_in_ipa
= (sizeof (struct collect_memory_action
)
527 - offsetof (struct tracepoint_action
, type
));
528 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
530 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
536 m_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
538 struct collect_memory_action
*maction
539 = (struct collect_memory_action
*) action
;
541 COPY_FIELD_TO_BUF (buffer
, maction
, addr
);
542 COPY_FIELD_TO_BUF (buffer
, maction
, len
);
543 COPY_FIELD_TO_BUF (buffer
, maction
, basereg
);
548 static const struct tracepoint_action_ops m_tracepoint_action_ops
=
550 m_tracepoint_action_download
,
551 m_tracepoint_action_send
,
555 r_tracepoint_action_download (const struct tracepoint_action
*action
)
557 int size_in_ipa
= (sizeof (struct collect_registers_action
)
558 - offsetof (struct tracepoint_action
, type
));
559 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
561 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
568 r_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
573 static const struct tracepoint_action_ops r_tracepoint_action_ops
=
575 r_tracepoint_action_download
,
576 r_tracepoint_action_send
,
579 static CORE_ADDR
download_agent_expr (struct agent_expr
*expr
);
582 x_tracepoint_action_download (const struct tracepoint_action
*action
)
584 int size_in_ipa
= (sizeof (struct eval_expr_action
)
585 - offsetof (struct tracepoint_action
, type
));
586 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
589 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
591 expr
= download_agent_expr (((struct eval_expr_action
*)action
)->expr
);
592 write_inferior_data_ptr (ipa_action
+ offsetof (struct eval_expr_action
, expr
)
593 - offsetof (struct tracepoint_action
, type
),
599 /* Copy agent expression AEXPR to buffer pointed by P. If AEXPR is NULL,
600 copy 0 to P. Return updated header of buffer. */
603 agent_expr_send (char *p
, const struct agent_expr
*aexpr
)
605 /* Copy the length of condition first, and then copy its
614 memcpy (p
, &aexpr
->length
, 4);
617 memcpy (p
, aexpr
->bytes
, aexpr
->length
);
624 x_tracepoint_action_send ( char *buffer
, const struct tracepoint_action
*action
)
626 struct eval_expr_action
*eaction
= (struct eval_expr_action
*) action
;
628 return agent_expr_send (buffer
, eaction
->expr
);
631 static const struct tracepoint_action_ops x_tracepoint_action_ops
=
633 x_tracepoint_action_download
,
634 x_tracepoint_action_send
,
638 l_tracepoint_action_download (const struct tracepoint_action
*action
)
640 int size_in_ipa
= (sizeof (struct collect_static_trace_data_action
)
641 - offsetof (struct tracepoint_action
, type
));
642 CORE_ADDR ipa_action
= target_malloc (size_in_ipa
);
644 write_inferior_memory (ipa_action
, (unsigned char *) &action
->type
,
651 l_tracepoint_action_send (char *buffer
, const struct tracepoint_action
*action
)
656 static const struct tracepoint_action_ops l_tracepoint_action_ops
=
658 l_tracepoint_action_download
,
659 l_tracepoint_action_send
,
663 /* This structure describes a piece of the source-level definition of
664 the tracepoint. The contents are not interpreted by the target,
665 but preserved verbatim for uploading upon reconnection. */
669 /* The type of string, such as "cond" for a conditional. */
672 /* The source-level string itself. For the sake of target
673 debugging, we store it in plaintext, even though it is always
674 transmitted in hex. */
677 /* Link to the next one in the list. We link them in the order
678 received, in case some make up an ordered list of commands or
680 struct source_string
*next
;
685 /* Trap based tracepoint. */
688 /* A fast tracepoint implemented with a jump instead of a trap. */
691 /* A static tracepoint, implemented by a program call into a tracing
696 struct tracepoint_hit_ctx
;
698 typedef enum eval_result_type (*condfn
) (unsigned char *,
701 /* The definition of a tracepoint. */
703 /* Tracepoints may have multiple locations, each at a different
704 address. This can occur with optimizations, template
705 instantiation, etc. Since the locations may be in different
706 scopes, the conditions and actions may be different for each
707 location. Our target version of tracepoints is more like GDB's
708 notion of "breakpoint locations", but we have almost nothing that
709 is not per-location, so we bother having two kinds of objects. The
710 key consequence is that numbers are not unique, and that it takes
711 both number and address to identify a tracepoint uniquely. */
715 /* The number of the tracepoint, as specified by GDB. Several
716 tracepoint objects here may share a number. */
719 /* Address at which the tracepoint is supposed to trigger. Several
720 tracepoints may share an address. */
723 /* Tracepoint type. */
724 enum tracepoint_type type
;
726 /* True if the tracepoint is currently enabled. */
729 /* The number of single steps that will be performed after each
733 /* The number of times the tracepoint may be hit before it will
734 terminate the entire tracing run. */
737 /* Pointer to the agent expression that is the tracepoint's
738 conditional, or NULL if the tracepoint is unconditional. */
739 struct agent_expr
*cond
;
741 /* The list of actions to take when the tracepoint triggers. */
743 struct tracepoint_action
**actions
;
745 /* Count of the times we've hit this tracepoint during the run.
746 Note that while-stepping steps are not counted as "hits". */
749 /* Cached sum of the sizes of traceframes created by this point. */
750 uint64_t traceframe_usage
;
752 CORE_ADDR compiled_cond
;
754 /* Link to the next tracepoint in the list. */
755 struct tracepoint
*next
;
757 #ifndef IN_PROCESS_AGENT
758 /* The list of actions to take when the tracepoint triggers, in
759 string/packet form. */
762 /* The collection of strings that describe the tracepoint as it was
763 entered into GDB. These are not used by the target, but are
764 reported back to GDB upon reconnection. */
765 struct source_string
*source_strings
;
767 /* The number of bytes displaced by fast tracepoints. It may subsume
768 multiple instructions, for multi-byte fast tracepoints. This
769 field is only valid for fast tracepoints. */
772 /* Only for fast tracepoints. */
773 CORE_ADDR obj_addr_on_target
;
775 /* Address range where the original instruction under a fast
776 tracepoint was relocated to. (_end is actually one byte past
778 CORE_ADDR adjusted_insn_addr
;
779 CORE_ADDR adjusted_insn_addr_end
;
781 /* The address range of the piece of the jump pad buffer that was
782 assigned to this fast tracepoint. (_end is actually one byte
785 CORE_ADDR jump_pad_end
;
787 /* The address range of the piece of the trampoline buffer that was
788 assigned to this fast tracepoint. (_end is actually one byte
790 CORE_ADDR trampoline
;
791 CORE_ADDR trampoline_end
;
793 /* The list of actions to take while in a stepping loop. These
794 fields are only valid for patch-based tracepoints. */
795 int num_step_actions
;
796 struct tracepoint_action
**step_actions
;
797 /* Same, but in string/packet form. */
798 char **step_actions_str
;
800 /* Handle returned by the breakpoint or tracepoint module when we
801 inserted the trap or jump, or hooked into a static tracepoint.
802 NULL if we haven't inserted it yet. */
808 #ifndef IN_PROCESS_AGENT
810 /* Given `while-stepping', a thread may be collecting data for more
811 than one tracepoint simultaneously. On the other hand, the same
812 tracepoint with a while-stepping action may be hit by more than one
813 thread simultaneously (but not quite, each thread could be handling
814 a different step). Each thread holds a list of these objects,
815 representing the current step of each while-stepping action being
820 struct wstep_state
*next
;
822 /* The tracepoint number. */
824 /* The tracepoint's address. */
825 CORE_ADDR tp_address
;
827 /* The number of the current step in this 'while-stepping'
836 /* The linked list of all tracepoints. Marked explicitly as used as
837 the in-process library doesn't use it for the fast tracepoints
839 IP_AGENT_EXPORT_VAR
struct tracepoint
*tracepoints
;
841 /* The first tracepoint to exceed its pass count. */
843 IP_AGENT_EXPORT_VAR
struct tracepoint
*stopping_tracepoint
;
845 /* True if the trace buffer is full or otherwise no longer usable. */
847 IP_AGENT_EXPORT_VAR
int trace_buffer_is_full
;
849 /* The first error that occurred during expression evaluation. */
851 /* Stored as an int to avoid the IPA ABI being dependent on whatever
852 the compiler decides to use for the enum's underlying type. Holds
853 enum eval_result_type values. */
854 IP_AGENT_EXPORT_VAR
int expr_eval_result
= expr_eval_no_error
;
858 #ifndef IN_PROCESS_AGENT
860 /* Pointer to the last tracepoint in the list, new tracepoints are
861 linked in at the end. */
863 static struct tracepoint
*last_tracepoint
;
865 static const char *eval_result_names
[] =
867 "terror:in the attic", /* this should never be reported */
868 "terror:empty expression",
869 "terror:empty stack",
870 "terror:stack overflow",
871 "terror:stack underflow",
872 "terror:unhandled opcode",
873 "terror:unrecognized opcode",
874 "terror:divide by zero"
879 /* The tracepoint in which the error occurred. */
882 IP_AGENT_EXPORT_VAR
struct tracepoint
*error_tracepoint
;
885 struct trace_state_variable
887 /* This is the name of the variable as used in GDB. The target
888 doesn't use the name, but needs to have it for saving and
889 reconnection purposes. */
892 /* This number identifies the variable uniquely. Numbers may be
893 assigned either by the target (in the case of builtin variables),
894 or by GDB, and are presumed unique during the course of a trace
898 /* The variable's initial value, a 64-bit signed integer always. */
899 LONGEST initial_value
;
901 /* The variable's value, a 64-bit signed integer always. */
904 /* Pointer to a getter function, used to supply computed values. */
905 LONGEST (*getter
) (void);
907 /* Link to the next variable. */
908 struct trace_state_variable
*next
;
911 /* Linked list of all trace state variables. */
913 #ifdef IN_PROCESS_AGENT
914 struct trace_state_variable
*alloced_trace_state_variables
;
917 IP_AGENT_EXPORT_VAR
struct trace_state_variable
*trace_state_variables
;
919 /* The results of tracing go into a fixed-size space known as the
920 "trace buffer". Because usage follows a limited number of
921 patterns, we manage it ourselves rather than with malloc. Basic
922 rules are that we create only one trace frame at a time, each is
923 variable in size, they are never moved once created, and we only
924 discard if we are doing a circular buffer, and then only the oldest
925 ones. Each trace frame includes its own size, so we don't need to
926 link them together, and the trace frame number is relative to the
927 first one, so we don't need to record numbers. A trace frame also
928 records the number of the tracepoint that created it. The data
929 itself is a series of blocks, each introduced by a single character
930 and with a defined format. Each type of block has enough
931 type/length info to allow scanners to jump quickly from one block
932 to the next without reading each byte in the block. */
934 /* Trace buffer management would be simple - advance a free pointer
935 from beginning to end, then stop - were it not for the circular
936 buffer option, which is a useful way to prevent a trace run from
937 stopping prematurely because the buffer filled up. In the circular
938 case, the location of the first trace frame (trace_buffer_start)
939 moves as old trace frames are discarded. Also, since we grow trace
940 frames incrementally as actions are performed, we wrap around to
941 the beginning of the trace buffer. This is per-block, so each
942 block within a trace frame remains contiguous. Things get messy
943 when the wrapped-around trace frame is the one being discarded; the
944 free space ends up in two parts at opposite ends of the buffer. */
947 # if defined(__GNUC__)
948 # define ATTR_PACKED __attribute__ ((packed))
950 # define ATTR_PACKED /* nothing */
954 /* The data collected at a tracepoint hit. This object should be as
955 small as possible, since there may be a great many of them. We do
956 not need to keep a frame number, because they are all sequential
957 and there are no deletions; so the Nth frame in the buffer is
958 always frame number N. */
962 /* Number of the tracepoint that collected this traceframe. A value
963 of 0 indicates the current end of the trace buffer. We make this
964 a 16-bit field because it's never going to happen that GDB's
965 numbering of tracepoints reaches 32,000. */
968 /* The size of the data in this trace frame. We limit this to 32
969 bits, even on a 64-bit target, because it's just implausible that
970 one is validly going to collect 4 gigabytes of data at a single
972 unsigned int data_size
: 32;
974 /* The base of the trace data, which is contiguous from this point. */
975 unsigned char data
[0];
979 /* The size of the EOB marker, in bytes. A traceframe with zeroed
980 fields (and no data) marks the end of trace data. */
981 #define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
983 /* The traceframe to be used as the source of data to send back to
984 GDB. A value of -1 means to get data from the live program. */
986 int current_traceframe
= -1;
988 /* This flag is true if the trace buffer is circular, meaning that
989 when it fills, the oldest trace frames are discarded in order to
992 #ifndef IN_PROCESS_AGENT
993 static int circular_trace_buffer
;
996 /* Size of the trace buffer. */
998 static LONGEST trace_buffer_size
;
1002 /* Pointer to the block of memory that traceframes all go into. */
1004 IP_AGENT_EXPORT_VAR
unsigned char *trace_buffer_lo
;
1006 /* Pointer to the end of the trace buffer, more precisely to the byte
1007 after the end of the buffer. */
1009 IP_AGENT_EXPORT_VAR
unsigned char *trace_buffer_hi
;
1013 /* Control structure holding the read/write/etc. pointers into the
1014 trace buffer. We need more than one of these to implement a
1015 transaction-like mechanism to garantees that both GDBserver and the
1016 in-process agent can try to change the trace buffer
1019 struct trace_buffer_control
1021 /* Pointer to the first trace frame in the buffer. In the
1022 non-circular case, this is equal to trace_buffer_lo, otherwise it
1023 moves around in the buffer. */
1024 unsigned char *start
;
1026 /* Pointer to the free part of the trace buffer. Note that we clear
1027 several bytes at and after this pointer, so that traceframe
1028 scans/searches terminate properly. */
1029 unsigned char *free
;
1031 /* Pointer to the byte after the end of the free part. Note that
1032 this may be smaller than trace_buffer_free in the circular case,
1033 and means that the free part is in two pieces. Initially it is
1034 equal to trace_buffer_hi, then is generally equivalent to
1035 trace_buffer_start. */
1036 unsigned char *end_free
;
1038 /* Pointer to the wraparound. If not equal to trace_buffer_hi, then
1039 this is the point at which the trace data breaks, and resumes at
1041 unsigned char *wrap
;
1044 /* Same as above, to be used by GDBserver when updating the in-process
1046 struct ipa_trace_buffer_control
1055 /* We have possibly both GDBserver and an inferior thread accessing
1056 the same IPA trace buffer memory. The IPA is the producer (tries
1057 to put new frames in the buffer), while GDBserver occasionally
1058 consumes them, that is, flushes the IPA's buffer into its own
1059 buffer. Both sides need to update the trace buffer control
1060 pointers (current head, tail, etc.). We can't use a global lock to
1061 synchronize the accesses, as otherwise we could deadlock GDBserver
1062 (if the thread holding the lock stops for a signal, say). So
1063 instead of that, we use a transaction scheme where GDBserver writes
1064 always prevail over the IPAs writes, and, we have the IPA detect
1065 the commit failure/overwrite, and retry the whole attempt. This is
1066 mainly implemented by having a global token object that represents
1067 who wrote last to the buffer control structure. We need to freeze
1068 any inferior writing to the buffer while GDBserver touches memory,
1069 so that the inferior can correctly detect that GDBserver had been
1070 there, otherwise, it could mistakingly think its commit was
1071 successful; that's implemented by simply having GDBserver set a
1072 breakpoint the inferior hits if it is the critical region.
1074 There are three cycling trace buffer control structure copies
1075 (buffer head, tail, etc.), with the token object including an index
1076 indicating which is current live copy. The IPA tentatively builds
1077 an updated copy in a non-current control structure, while GDBserver
1078 always clobbers the current version directly. The IPA then tries
1079 to atomically "commit" its version; if GDBserver clobbered the
1080 structure meanwhile, that will fail, and the IPA restarts the
1083 Listing the step in further detail, we have:
1085 In-process agent (producer):
1087 - passes by `about_to_request_buffer_space' breakpoint/lock
1089 - reads current token, extracts current trace buffer control index,
1090 and starts tentatively updating the rightmost one (0->1, 1->2,
1091 2->0). Note that only one inferior thread is executing this code
1092 at any given time, due to an outer lock in the jump pads.
1094 - updates counters, and tries to commit the token.
1096 - passes by second `about_to_request_buffer_space' breakpoint/lock,
1097 leaving the sync region.
1099 - checks if the update was effective.
1101 - if trace buffer was found full, hits flush_trace_buffer
1102 breakpoint, and restarts later afterwards.
1104 GDBserver (consumer):
1106 - sets `about_to_request_buffer_space' breakpoint/lock.
1108 - updates the token unconditionally, using the current buffer
1109 control index, since it knows that the IP agent always writes to
1110 the rightmost, and due to the breakpoint, at most one IP thread
1111 can try to update the trace buffer concurrently to GDBserver, so
1112 there will be no danger of trace buffer control index wrap making
1113 the IPA write to the same index as GDBserver.
1115 - flushes the IP agent's trace buffer completely, and updates the
1116 current trace buffer control structure. GDBserver *always* wins.
1118 - removes the `about_to_request_buffer_space' breakpoint.
1120 The token is stored in the `trace_buffer_ctrl_curr' variable.
1121 Internally, it's bits are defined as:
1123 |-------------+-----+-------------+--------+-------------+--------------|
1124 | Bit offsets | 31 | 30 - 20 | 19 | 18-8 | 7-0 |
1125 |-------------+-----+-------------+--------+-------------+--------------|
1126 | What | GSB | PC (11-bit) | unused | CC (11-bit) | TBCI (8-bit) |
1127 |-------------+-----+-------------+--------+-------------+--------------|
1129 GSB - GDBserver Stamp Bit
1130 PC - Previous Counter
1131 CC - Current Counter
1132 TBCI - Trace Buffer Control Index
1135 An IPA update of `trace_buffer_ctrl_curr' does:
1137 - read CC from the current token, save as PC.
1139 - atomically tries to write PC+1,CC
1141 A GDBserver update of `trace_buffer_ctrl_curr' does:
1143 - reads PC and CC from the current token.
1148 /* These are the bits of `trace_buffer_ctrl_curr' that are reserved
1149 for the counters described below. The cleared bits are used to
1150 hold the index of the items of the `trace_buffer_ctrl' array that
1152 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1154 /* `trace_buffer_ctrl_curr' contains two counters. The `previous'
1155 counter, and the `current' counter. */
1157 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1158 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1160 /* When GDBserver update the IP agent's `trace_buffer_ctrl_curr', it
1161 always stamps this bit as set. */
1162 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1164 #ifdef IN_PROCESS_AGENT
1165 IP_AGENT_EXPORT_VAR
struct trace_buffer_control trace_buffer_ctrl
[3];
1166 IP_AGENT_EXPORT_VAR
unsigned int trace_buffer_ctrl_curr
;
1168 # define TRACE_BUFFER_CTRL_CURR \
1169 (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1173 /* The GDBserver side agent only needs one instance of this object, as
1174 it doesn't need to sync with itself. Define it as array anyway so
1175 that the rest of the code base doesn't need to care for the
1177 struct trace_buffer_control trace_buffer_ctrl
[1];
1178 # define TRACE_BUFFER_CTRL_CURR 0
1181 /* These are convenience macros used to access the current trace
1182 buffer control in effect. */
1183 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1184 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1185 #define trace_buffer_end_free \
1186 (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1187 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1190 /* Macro that returns a pointer to the first traceframe in the buffer. */
1192 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1194 /* Macro that returns a pointer to the next traceframe in the buffer.
1195 If the computed location is beyond the wraparound point, subtract
1196 the offset of the wraparound. */
1198 #define NEXT_TRACEFRAME_1(TF) \
1199 (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1201 #define NEXT_TRACEFRAME(TF) \
1202 ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1203 - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1204 ? (trace_buffer_wrap - trace_buffer_lo) \
1207 /* The difference between these counters represents the total number
1208 of complete traceframes present in the trace buffer. The IP agent
1209 writes to the write count, GDBserver writes to read count. */
1211 IP_AGENT_EXPORT_VAR
unsigned int traceframe_write_count
;
1212 IP_AGENT_EXPORT_VAR
unsigned int traceframe_read_count
;
1214 /* Convenience macro. */
1216 #define traceframe_count \
1217 ((unsigned int) (traceframe_write_count - traceframe_read_count))
1219 /* The count of all traceframes created in the current run, including
1220 ones that were discarded to make room. */
1222 IP_AGENT_EXPORT_VAR
int traceframes_created
;
1224 #ifndef IN_PROCESS_AGENT
1226 /* Read-only regions are address ranges whose contents don't change,
1227 and so can be read from target memory even while looking at a trace
1228 frame. Without these, disassembly for instance will likely fail,
1229 because the program code is not usually collected into a trace
1230 frame. This data structure does not need to be very complicated or
1231 particularly efficient, it's only going to be used occasionally,
1232 and only by some commands. */
1234 struct readonly_region
1236 /* The bounds of the region. */
1237 CORE_ADDR start
, end
;
1239 /* Link to the next one. */
1240 struct readonly_region
*next
;
1243 /* Linked list of readonly regions. This list stays in effect from
1244 one tstart to the next. */
1246 static struct readonly_region
*readonly_regions
;
1250 /* The global that controls tracing overall. */
1252 IP_AGENT_EXPORT_VAR
int tracing
;
1254 #ifndef IN_PROCESS_AGENT
1256 /* Controls whether tracing should continue after GDB disconnects. */
1258 int disconnected_tracing
;
1260 /* The reason for the last tracing run to have stopped. We initialize
1261 to a distinct string so that GDB can distinguish between "stopped
1262 after running" and "stopped because never run" cases. */
1264 static const char *tracing_stop_reason
= "tnotrun";
1266 static int tracing_stop_tpnum
;
1268 /* 64-bit timestamps for the trace run's start and finish, expressed
1269 in microseconds from the Unix epoch. */
1271 LONGEST tracing_start_time
;
1272 LONGEST tracing_stop_time
;
1274 /* The (optional) user-supplied name of the user that started the run.
1275 This is an arbitrary string, and may be NULL. */
1277 char *tracing_user_name
;
1279 /* Optional user-supplied text describing the run. This is
1280 an arbitrary string, and may be NULL. */
1282 char *tracing_notes
;
1284 /* Optional user-supplied text explaining a tstop command. This is an
1285 arbitrary string, and may be NULL. */
1287 char *tracing_stop_note
;
1291 /* Functions local to this file. */
1293 /* Base "class" for tracepoint type specific data to be passed down to
1294 collect_data_at_tracepoint. */
1295 struct tracepoint_hit_ctx
1297 enum tracepoint_type type
;
1300 #ifdef IN_PROCESS_AGENT
1302 /* Fast/jump tracepoint specific data to be passed down to
1303 collect_data_at_tracepoint. */
1304 struct fast_tracepoint_ctx
1306 struct tracepoint_hit_ctx base
;
1308 struct regcache regcache
;
1309 int regcache_initted
;
1310 unsigned char *regspace
;
1312 unsigned char *regs
;
1313 struct tracepoint
*tpoint
;
1316 /* Static tracepoint specific data to be passed down to
1317 collect_data_at_tracepoint. */
1318 struct static_tracepoint_ctx
1320 struct tracepoint_hit_ctx base
;
1322 /* The regcache corresponding to the registers state at the time of
1323 the tracepoint hit. Initialized lazily, from REGS. */
1324 struct regcache regcache
;
1325 int regcache_initted
;
1327 /* The buffer space REGCACHE above uses. We use a separate buffer
1328 instead of letting the regcache malloc for both signal safety and
1329 performance reasons; this is allocated on the stack instead. */
1330 unsigned char *regspace
;
1332 /* The register buffer as passed on by lttng/ust. */
1333 struct registers
*regs
;
1335 /* The "printf" formatter and the args the user passed to the marker
1336 call. We use this to be able to collect "static trace data"
1341 /* The GDB tracepoint matching the probed marker that was "hit". */
1342 struct tracepoint
*tpoint
;
1347 /* Static tracepoint specific data to be passed down to
1348 collect_data_at_tracepoint. */
1349 struct trap_tracepoint_ctx
1351 struct tracepoint_hit_ctx base
;
1353 struct regcache
*regcache
;
1358 #ifndef IN_PROCESS_AGENT
1359 static CORE_ADDR
traceframe_get_pc (struct traceframe
*tframe
);
1360 static int traceframe_read_tsv (int num
, LONGEST
*val
);
1363 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1364 struct tracepoint
*tpoint
);
1366 #ifndef IN_PROCESS_AGENT
1367 static void clear_readonly_regions (void);
1368 static void clear_installed_tracepoints (void);
1371 static void collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1373 struct tracepoint
*tpoint
);
1374 #ifndef IN_PROCESS_AGENT
1375 static void collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
1377 struct tracepoint
*tpoint
, int current_step
);
1378 static void compile_tracepoint_condition (struct tracepoint
*tpoint
,
1379 CORE_ADDR
*jump_entry
);
1381 static void do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1383 struct tracepoint
*tpoint
,
1384 struct traceframe
*tframe
,
1385 struct tracepoint_action
*taction
);
1387 #ifndef IN_PROCESS_AGENT
1388 static struct tracepoint
*fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR
);
1390 static void install_tracepoint (struct tracepoint
*, char *own_buf
);
1391 static void download_tracepoint (struct tracepoint
*);
1392 static int install_fast_tracepoint (struct tracepoint
*, char *errbuf
);
1393 static void clone_fast_tracepoint (struct tracepoint
*to
,
1394 const struct tracepoint
*from
);
1397 static LONGEST
get_timestamp (void);
1399 #if defined(__GNUC__)
1400 # define memory_barrier() asm volatile ("" : : : "memory")
1402 # define memory_barrier() do {} while (0)
1405 /* We only build the IPA if this builtin is supported, and there are
1406 no uses of this in GDBserver itself, so we're safe in defining this
1408 #define cmpxchg(mem, oldval, newval) \
1409 __sync_val_compare_and_swap (mem, oldval, newval)
1411 /* Record that an error occurred during expression evaluation. */
1414 record_tracepoint_error (struct tracepoint
*tpoint
, const char *which
,
1415 enum eval_result_type rtype
)
1417 trace_debug ("Tracepoint %d at %s %s eval reports error %d",
1418 tpoint
->number
, paddress (tpoint
->address
), which
, rtype
);
1420 #ifdef IN_PROCESS_AGENT
1421 /* Only record the first error we get. */
1422 if (cmpxchg (&expr_eval_result
,
1424 rtype
) != expr_eval_no_error
)
1427 if (expr_eval_result
!= expr_eval_no_error
)
1431 error_tracepoint
= tpoint
;
1434 /* Trace buffer management. */
1437 clear_trace_buffer (void)
1439 trace_buffer_start
= trace_buffer_lo
;
1440 trace_buffer_free
= trace_buffer_lo
;
1441 trace_buffer_end_free
= trace_buffer_hi
;
1442 trace_buffer_wrap
= trace_buffer_hi
;
1443 /* A traceframe with zeroed fields marks the end of trace data. */
1444 ((struct traceframe
*) trace_buffer_free
)->tpnum
= 0;
1445 ((struct traceframe
*) trace_buffer_free
)->data_size
= 0;
1446 traceframe_read_count
= traceframe_write_count
= 0;
1447 traceframes_created
= 0;
1450 #ifndef IN_PROCESS_AGENT
1453 clear_inferior_trace_buffer (void)
1455 CORE_ADDR ipa_trace_buffer_lo
;
1456 CORE_ADDR ipa_trace_buffer_hi
;
1457 struct traceframe ipa_traceframe
= { 0 };
1458 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
1460 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
1461 &ipa_trace_buffer_lo
);
1462 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
1463 &ipa_trace_buffer_hi
);
1465 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
1466 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
1467 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
1468 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
1470 /* A traceframe with zeroed fields marks the end of trace data. */
1471 write_inferior_memory (ipa_sym_addrs
.addr_trace_buffer_ctrl
,
1472 (unsigned char *) &ipa_trace_buffer_ctrl
,
1473 sizeof (ipa_trace_buffer_ctrl
));
1475 write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
, 0);
1477 /* A traceframe with zeroed fields marks the end of trace data. */
1478 write_inferior_memory (ipa_trace_buffer_lo
,
1479 (unsigned char *) &ipa_traceframe
,
1480 sizeof (ipa_traceframe
));
1482 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
, 0);
1483 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
, 0);
1484 write_inferior_integer (ipa_sym_addrs
.addr_traceframes_created
, 0);
1490 init_trace_buffer (LONGEST bufsize
)
1494 trace_buffer_size
= bufsize
;
1496 /* Make sure to internally allocate at least space for the EOB
1498 alloc_size
= (bufsize
< TRACEFRAME_EOB_MARKER_SIZE
1499 ? TRACEFRAME_EOB_MARKER_SIZE
: bufsize
);
1500 trace_buffer_lo
= (unsigned char *) xrealloc (trace_buffer_lo
, alloc_size
);
1502 trace_buffer_hi
= trace_buffer_lo
+ trace_buffer_size
;
1504 clear_trace_buffer ();
1507 #ifdef IN_PROCESS_AGENT
1509 IP_AGENT_EXPORT_FUNC
void
1510 about_to_request_buffer_space (void)
1512 /* GDBserver places breakpoint here while it goes about to flush
1513 data at random times. */
1514 UNKNOWN_SIDE_EFFECTS();
1519 /* Carve out a piece of the trace buffer, returning NULL in case of
1523 trace_buffer_alloc (size_t amt
)
1525 unsigned char *rslt
;
1526 struct trace_buffer_control
*tbctrl
;
1528 #ifdef IN_PROCESS_AGENT
1529 unsigned int prev
, prev_filtered
;
1530 unsigned int commit_count
;
1531 unsigned int commit
;
1532 unsigned int readout
;
1534 struct traceframe
*oldest
;
1535 unsigned char *new_start
;
1538 trace_debug ("Want to allocate %ld+%ld bytes in trace buffer",
1539 (long) amt
, (long) sizeof (struct traceframe
));
1541 /* Account for the EOB marker. */
1542 amt
+= TRACEFRAME_EOB_MARKER_SIZE
;
1544 #ifdef IN_PROCESS_AGENT
1548 /* Read the current token and extract the index to try to write to,
1549 storing it in CURR. */
1550 prev
= trace_buffer_ctrl_curr
;
1551 prev_filtered
= prev
& ~GDBSERVER_FLUSH_COUNT_MASK
;
1552 curr
= prev_filtered
+ 1;
1556 about_to_request_buffer_space ();
1558 /* Start out with a copy of the current state. GDBserver may be
1559 midway writing to the PREV_FILTERED TBC, but, that's OK, we won't
1560 be able to commit anyway if that happens. */
1561 trace_buffer_ctrl
[curr
]
1562 = trace_buffer_ctrl
[prev_filtered
];
1563 trace_debug ("trying curr=%u", curr
);
1565 /* The GDBserver's agent doesn't need all that syncing, and always
1566 updates TCB 0 (there's only one, mind you). */
1569 tbctrl
= &trace_buffer_ctrl
[curr
];
1571 /* Offsets are easier to grok for debugging than raw addresses,
1572 especially for the small trace buffer sizes that are useful for
1574 trace_debug ("Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1576 (int) (tbctrl
->start
- trace_buffer_lo
),
1577 (int) (tbctrl
->free
- trace_buffer_lo
),
1578 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1579 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1580 (int) (trace_buffer_hi
- trace_buffer_lo
));
1582 /* The algorithm here is to keep trying to get a contiguous block of
1583 the requested size, possibly discarding older traceframes to free
1584 up space. Since free space might come in one or two pieces,
1585 depending on whether discarded traceframes wrapped around at the
1586 high end of the buffer, we test both pieces after each
1590 /* First, if we have two free parts, try the upper one first. */
1591 if (tbctrl
->end_free
< tbctrl
->free
)
1593 if (tbctrl
->free
+ amt
<= trace_buffer_hi
)
1594 /* We have enough in the upper part. */
1598 /* Our high part of free space wasn't enough. Give up
1599 on it for now, set wraparound. We will recover the
1600 space later, if/when the wrapped-around traceframe is
1602 trace_debug ("Upper part too small, setting wraparound");
1603 tbctrl
->wrap
= tbctrl
->free
;
1604 tbctrl
->free
= trace_buffer_lo
;
1608 /* The normal case. */
1609 if (tbctrl
->free
+ amt
<= tbctrl
->end_free
)
1612 #ifdef IN_PROCESS_AGENT
1613 /* The IP Agent's buffer is always circular. It isn't used
1614 currently, but `circular_trace_buffer' could represent
1615 GDBserver's mode. If we didn't find space, ask GDBserver to
1618 flush_trace_buffer ();
1622 trace_debug ("gdbserver flushed buffer, retrying");
1626 /* GDBserver cancelled the tracing. Bail out as well. */
1629 /* If we're here, then neither part is big enough, and
1630 non-circular trace buffers are now full. */
1631 if (!circular_trace_buffer
)
1633 trace_debug ("Not enough space in the trace buffer");
1637 trace_debug ("Need more space in the trace buffer");
1639 /* If we have a circular buffer, we can try discarding the
1640 oldest traceframe and see if that helps. */
1641 oldest
= FIRST_TRACEFRAME ();
1642 if (oldest
->tpnum
== 0)
1644 /* Not good; we have no traceframes to free. Perhaps we're
1645 asking for a block that is larger than the buffer? In
1646 any case, give up. */
1647 trace_debug ("No traceframes to discard");
1651 /* We don't run this code in the in-process agent currently.
1652 E.g., we could leave the in-process agent in autonomous
1653 circular mode if we only have fast tracepoints. If we do
1654 that, then this bit becomes racy with GDBserver, which also
1655 writes to this counter. */
1656 --traceframe_write_count
;
1658 new_start
= (unsigned char *) NEXT_TRACEFRAME (oldest
);
1659 /* If we freed the traceframe that wrapped around, go back
1660 to the non-wrap case. */
1661 if (new_start
< tbctrl
->start
)
1663 trace_debug ("Discarding past the wraparound");
1664 tbctrl
->wrap
= trace_buffer_hi
;
1666 tbctrl
->start
= new_start
;
1667 tbctrl
->end_free
= tbctrl
->start
;
1669 trace_debug ("Discarded a traceframe\n"
1670 "Trace buffer [%d], start=%d free=%d "
1671 "endfree=%d wrap=%d hi=%d",
1673 (int) (tbctrl
->start
- trace_buffer_lo
),
1674 (int) (tbctrl
->free
- trace_buffer_lo
),
1675 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1676 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1677 (int) (trace_buffer_hi
- trace_buffer_lo
));
1679 /* Now go back around the loop. The discard might have resulted
1680 in either one or two pieces of free space, so we want to try
1681 both before freeing any more traceframes. */
1685 /* If we get here, we know we can provide the asked-for space. */
1687 rslt
= tbctrl
->free
;
1689 /* Adjust the request back down, now that we know we have space for
1690 the marker, but don't commit to AMT yet, we may still need to
1691 restart the operation if GDBserver touches the trace buffer
1692 (obviously only important in the in-process agent's version). */
1693 tbctrl
->free
+= (amt
- sizeof (struct traceframe
));
1695 /* Or not. If GDBserver changed the trace buffer behind our back,
1696 we get to restart a new allocation attempt. */
1698 #ifdef IN_PROCESS_AGENT
1699 /* Build the tentative token. */
1700 commit_count
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) + 0x100)
1701 & GDBSERVER_FLUSH_COUNT_MASK_CURR
);
1702 commit
= (((prev
& GDBSERVER_FLUSH_COUNT_MASK_CURR
) << 12)
1706 /* Try to commit it. */
1707 readout
= cmpxchg (&trace_buffer_ctrl_curr
, prev
, commit
);
1708 if (readout
!= prev
)
1710 trace_debug ("GDBserver has touched the trace buffer, restarting."
1711 " (prev=%08x, commit=%08x, readout=%08x)",
1712 prev
, commit
, readout
);
1716 /* Hold your horses here. Even if that change was committed,
1717 GDBserver could come in, and clobber it. We need to hold to be
1718 able to tell if GDBserver clobbers before or after we committed
1719 the change. Whenever GDBserver goes about touching the IPA
1720 buffer, it sets a breakpoint in this routine, so we have a sync
1722 about_to_request_buffer_space ();
1724 /* Check if the change has been effective, even if GDBserver stopped
1725 us at the breakpoint. */
1728 unsigned int refetch
;
1732 refetch
= trace_buffer_ctrl_curr
;
1734 if (refetch
== commit
1735 || ((refetch
& GDBSERVER_FLUSH_COUNT_MASK_PREV
) >> 12) == commit_count
)
1738 trace_debug ("change is effective: (prev=%08x, commit=%08x, "
1739 "readout=%08x, refetch=%08x)",
1740 prev
, commit
, readout
, refetch
);
1744 trace_debug ("GDBserver has touched the trace buffer, not effective."
1745 " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1746 prev
, commit
, readout
, refetch
);
1752 /* We have a new piece of the trace buffer. Hurray! */
1754 /* Add an EOB marker just past this allocation. */
1755 ((struct traceframe
*) tbctrl
->free
)->tpnum
= 0;
1756 ((struct traceframe
*) tbctrl
->free
)->data_size
= 0;
1758 /* Adjust the request back down, now that we know we have space for
1760 amt
-= sizeof (struct traceframe
);
1764 trace_debug ("Allocated %d bytes", (int) amt
);
1765 trace_debug ("Trace buffer [%d] start=%d free=%d "
1766 "endfree=%d wrap=%d hi=%d",
1768 (int) (tbctrl
->start
- trace_buffer_lo
),
1769 (int) (tbctrl
->free
- trace_buffer_lo
),
1770 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1771 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1772 (int) (trace_buffer_hi
- trace_buffer_lo
));
1778 #ifndef IN_PROCESS_AGENT
1780 /* Return the total free space. This is not necessarily the largest
1781 block we can allocate, because of the two-part case. */
1786 if (trace_buffer_free
<= trace_buffer_end_free
)
1787 return trace_buffer_end_free
- trace_buffer_free
;
1789 return ((trace_buffer_end_free
- trace_buffer_lo
)
1790 + (trace_buffer_hi
- trace_buffer_free
));
1793 /* An 'S' in continuation packets indicates remainder are for
1796 static int seen_step_action_flag
;
1798 /* Create a tracepoint (location) with given number and address. Add this
1799 new tracepoint to list and sort this list. */
1801 static struct tracepoint
*
1802 add_tracepoint (int num
, CORE_ADDR addr
)
1804 struct tracepoint
*tpoint
, **tp_next
;
1806 tpoint
= XNEW (struct tracepoint
);
1807 tpoint
->number
= num
;
1808 tpoint
->address
= addr
;
1809 tpoint
->numactions
= 0;
1810 tpoint
->actions
= NULL
;
1811 tpoint
->actions_str
= NULL
;
1812 tpoint
->cond
= NULL
;
1813 tpoint
->num_step_actions
= 0;
1814 tpoint
->step_actions
= NULL
;
1815 tpoint
->step_actions_str
= NULL
;
1816 /* Start all off as regular (slow) tracepoints. */
1817 tpoint
->type
= trap_tracepoint
;
1818 tpoint
->orig_size
= -1;
1819 tpoint
->source_strings
= NULL
;
1820 tpoint
->compiled_cond
= 0;
1821 tpoint
->handle
= NULL
;
1822 tpoint
->next
= NULL
;
1824 /* Find a place to insert this tracepoint into list in order to keep
1825 the tracepoint list still in the ascending order. There may be
1826 multiple tracepoints at the same address as TPOINT's, and this
1827 guarantees TPOINT is inserted after all the tracepoints which are
1828 set at the same address. For example, fast tracepoints A, B, C are
1829 set at the same address, and D is to be insert at the same place as
1832 -->| A |--> | B |-->| C |->...
1834 One jump pad was created for tracepoint A, B, and C, and the target
1835 address of A is referenced/used in jump pad. So jump pad will let
1836 inferior jump to A. If D is inserted in front of A, like this,
1838 -->| D |-->| A |--> | B |-->| C |->...
1840 without updating jump pad, D is not reachable during collect, which
1841 is wrong. As we can see, the order of B, C and D doesn't matter, but
1842 A should always be the `first' one. */
1843 for (tp_next
= &tracepoints
;
1844 (*tp_next
) != NULL
&& (*tp_next
)->address
<= tpoint
->address
;
1845 tp_next
= &(*tp_next
)->next
)
1847 tpoint
->next
= *tp_next
;
1849 last_tracepoint
= tpoint
;
1851 seen_step_action_flag
= 0;
1856 #ifndef IN_PROCESS_AGENT
1858 /* Return the tracepoint with the given number and address, or NULL. */
1860 static struct tracepoint
*
1861 find_tracepoint (int id
, CORE_ADDR addr
)
1863 struct tracepoint
*tpoint
;
1865 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
1866 if (tpoint
->number
== id
&& tpoint
->address
== addr
)
1872 /* Remove TPOINT from global list. */
1875 remove_tracepoint (struct tracepoint
*tpoint
)
1877 struct tracepoint
*tp
, *tp_prev
;
1879 for (tp
= tracepoints
, tp_prev
= NULL
; tp
&& tp
!= tpoint
;
1880 tp_prev
= tp
, tp
= tp
->next
)
1886 tp_prev
->next
= tp
->next
;
1888 tracepoints
= tp
->next
;
1894 /* There may be several tracepoints with the same number (because they
1895 are "locations", in GDB parlance); return the next one after the
1896 given tracepoint, or search from the beginning of the list if the
1897 first argument is NULL. */
1899 static struct tracepoint
*
1900 find_next_tracepoint_by_number (struct tracepoint
*prev_tp
, int num
)
1902 struct tracepoint
*tpoint
;
1905 tpoint
= prev_tp
->next
;
1907 tpoint
= tracepoints
;
1908 for (; tpoint
; tpoint
= tpoint
->next
)
1909 if (tpoint
->number
== num
)
1917 /* Append another action to perform when the tracepoint triggers. */
1920 add_tracepoint_action (struct tracepoint
*tpoint
, char *packet
)
1926 seen_step_action_flag
= 1;
1934 char *act_start
= act
;
1935 struct tracepoint_action
*action
= NULL
;
1941 struct collect_memory_action
*maction
=
1942 XNEW (struct collect_memory_action
);
1946 maction
->base
.type
= *act
;
1947 maction
->base
.ops
= &m_tracepoint_action_ops
;
1948 action
= &maction
->base
;
1951 is_neg
= (*act
== '-');
1954 act
= unpack_varlen_hex (act
, &basereg
);
1956 act
= unpack_varlen_hex (act
, &maction
->addr
);
1958 act
= unpack_varlen_hex (act
, &maction
->len
);
1959 maction
->basereg
= (is_neg
1962 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
1963 pulongest (maction
->len
),
1964 paddress (maction
->addr
), maction
->basereg
);
1969 struct collect_registers_action
*raction
=
1970 XNEW (struct collect_registers_action
);
1972 raction
->base
.type
= *act
;
1973 raction
->base
.ops
= &r_tracepoint_action_ops
;
1974 action
= &raction
->base
;
1976 trace_debug ("Want to collect registers");
1978 /* skip past hex digits of mask for now */
1979 while (isxdigit(*act
))
1985 struct collect_static_trace_data_action
*raction
=
1986 XNEW (struct collect_static_trace_data_action
);
1988 raction
->base
.type
= *act
;
1989 raction
->base
.ops
= &l_tracepoint_action_ops
;
1990 action
= &raction
->base
;
1992 trace_debug ("Want to collect static trace data");
1997 trace_debug ("Unexpected step action, ignoring");
2002 struct eval_expr_action
*xaction
= XNEW (struct eval_expr_action
);
2004 xaction
->base
.type
= *act
;
2005 xaction
->base
.ops
= &x_tracepoint_action_ops
;
2006 action
= &xaction
->base
;
2008 trace_debug ("Want to evaluate expression");
2009 xaction
->expr
= gdb_parse_agent_expr (&act
);
2013 trace_debug ("unknown trace action '%c', ignoring...", *act
);
2022 if (seen_step_action_flag
)
2024 tpoint
->num_step_actions
++;
2026 tpoint
->step_actions
2027 = XRESIZEVEC (struct tracepoint_action
*, tpoint
->step_actions
,
2028 tpoint
->num_step_actions
);
2029 tpoint
->step_actions_str
2030 = XRESIZEVEC (char *, tpoint
->step_actions_str
,
2031 tpoint
->num_step_actions
);
2032 tpoint
->step_actions
[tpoint
->num_step_actions
- 1] = action
;
2033 tpoint
->step_actions_str
[tpoint
->num_step_actions
- 1]
2034 = savestring (act_start
, act
- act_start
);
2038 tpoint
->numactions
++;
2040 = XRESIZEVEC (struct tracepoint_action
*, tpoint
->actions
,
2041 tpoint
->numactions
);
2043 = XRESIZEVEC (char *, tpoint
->actions_str
, tpoint
->numactions
);
2044 tpoint
->actions
[tpoint
->numactions
- 1] = action
;
2045 tpoint
->actions_str
[tpoint
->numactions
- 1]
2046 = savestring (act_start
, act
- act_start
);
2053 /* Find or create a trace state variable with the given number. */
2055 static struct trace_state_variable
*
2056 get_trace_state_variable (int num
)
2058 struct trace_state_variable
*tsv
;
2060 #ifdef IN_PROCESS_AGENT
2061 /* Search for an existing variable. */
2062 for (tsv
= alloced_trace_state_variables
; tsv
; tsv
= tsv
->next
)
2063 if (tsv
->number
== num
)
2067 /* Search for an existing variable. */
2068 for (tsv
= trace_state_variables
; tsv
; tsv
= tsv
->next
)
2069 if (tsv
->number
== num
)
2075 /* Find or create a trace state variable with the given number. */
2077 static struct trace_state_variable
*
2078 create_trace_state_variable (int num
, int gdb
)
2080 struct trace_state_variable
*tsv
;
2082 tsv
= get_trace_state_variable (num
);
2086 /* Create a new variable. */
2087 tsv
= XNEW (struct trace_state_variable
);
2089 tsv
->initial_value
= 0;
2093 #ifdef IN_PROCESS_AGENT
2096 tsv
->next
= alloced_trace_state_variables
;
2097 alloced_trace_state_variables
= tsv
;
2102 tsv
->next
= trace_state_variables
;
2103 trace_state_variables
= tsv
;
2108 IP_AGENT_EXPORT_FUNC LONGEST
2109 get_trace_state_variable_value (int num
)
2111 struct trace_state_variable
*tsv
;
2113 tsv
= get_trace_state_variable (num
);
2117 trace_debug ("No trace state variable %d, skipping value get", num
);
2121 /* Call a getter function if we have one. While it's tempting to
2122 set up something to only call the getter once per tracepoint hit,
2123 it could run afoul of thread races. Better to let the getter
2124 handle it directly, if necessary to worry about it. */
2126 tsv
->value
= (tsv
->getter
) ();
2128 trace_debug ("get_trace_state_variable_value(%d) ==> %s",
2129 num
, plongest (tsv
->value
));
2134 IP_AGENT_EXPORT_FUNC
void
2135 set_trace_state_variable_value (int num
, LONGEST val
)
2137 struct trace_state_variable
*tsv
;
2139 tsv
= get_trace_state_variable (num
);
2143 trace_debug ("No trace state variable %d, skipping value set", num
);
2151 agent_get_trace_state_variable_value (int num
)
2153 return get_trace_state_variable_value (num
);
2157 agent_set_trace_state_variable_value (int num
, LONGEST val
)
2159 set_trace_state_variable_value (num
, val
);
2163 set_trace_state_variable_name (int num
, const char *name
)
2165 struct trace_state_variable
*tsv
;
2167 tsv
= get_trace_state_variable (num
);
2171 trace_debug ("No trace state variable %d, skipping name set", num
);
2175 tsv
->name
= (char *) name
;
2179 set_trace_state_variable_getter (int num
, LONGEST (*getter
) (void))
2181 struct trace_state_variable
*tsv
;
2183 tsv
= get_trace_state_variable (num
);
2187 trace_debug ("No trace state variable %d, skipping getter set", num
);
2191 tsv
->getter
= getter
;
2194 /* Add a raw traceframe for the given tracepoint. */
2196 static struct traceframe
*
2197 add_traceframe (struct tracepoint
*tpoint
)
2199 struct traceframe
*tframe
;
2202 = (struct traceframe
*) trace_buffer_alloc (sizeof (struct traceframe
));
2207 tframe
->tpnum
= tpoint
->number
;
2208 tframe
->data_size
= 0;
2213 /* Add a block to the traceframe currently being worked on. */
2215 static unsigned char *
2216 add_traceframe_block (struct traceframe
*tframe
,
2217 struct tracepoint
*tpoint
, int amt
)
2219 unsigned char *block
;
2224 block
= (unsigned char *) trace_buffer_alloc (amt
);
2229 gdb_assert (tframe
->tpnum
== tpoint
->number
);
2231 tframe
->data_size
+= amt
;
2232 tpoint
->traceframe_usage
+= amt
;
2237 /* Flag that the current traceframe is finished. */
2240 finish_traceframe (struct traceframe
*tframe
)
2242 ++traceframe_write_count
;
2243 ++traceframes_created
;
2246 #ifndef IN_PROCESS_AGENT
2248 /* Given a traceframe number NUM, find the NUMth traceframe in the
2251 static struct traceframe
*
2252 find_traceframe (int num
)
2254 struct traceframe
*tframe
;
2257 for (tframe
= FIRST_TRACEFRAME ();
2259 tframe
= NEXT_TRACEFRAME (tframe
))
2270 get_traceframe_address (struct traceframe
*tframe
)
2273 struct tracepoint
*tpoint
;
2275 addr
= traceframe_get_pc (tframe
);
2280 /* Fallback strategy, will be incorrect for while-stepping frames
2281 and multi-location tracepoints. */
2282 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
2283 return tpoint
->address
;
2286 /* Search for the next traceframe whose address is inside or outside
2289 static struct traceframe
*
2290 find_next_traceframe_in_range (CORE_ADDR lo
, CORE_ADDR hi
, int inside_p
,
2293 struct traceframe
*tframe
;
2296 *tfnump
= current_traceframe
+ 1;
2297 tframe
= find_traceframe (*tfnump
);
2298 /* The search is not supposed to wrap around. */
2305 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2307 tfaddr
= get_traceframe_address (tframe
);
2309 ? (lo
<= tfaddr
&& tfaddr
<= hi
)
2310 : (lo
> tfaddr
|| tfaddr
> hi
))
2319 /* Search for the next traceframe recorded by the given tracepoint.
2320 Note that for multi-location tracepoints, this will find whatever
2321 location appears first. */
2323 static struct traceframe
*
2324 find_next_traceframe_by_tracepoint (int num
, int *tfnump
)
2326 struct traceframe
*tframe
;
2328 *tfnump
= current_traceframe
+ 1;
2329 tframe
= find_traceframe (*tfnump
);
2330 /* The search is not supposed to wrap around. */
2337 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2339 if (tframe
->tpnum
== num
)
2350 #ifndef IN_PROCESS_AGENT
2352 /* Clear all past trace state. */
2355 cmd_qtinit (char *packet
)
2357 struct trace_state_variable
*tsv
, *prev
, *next
;
2359 /* Can't do this command without a pid attached. */
2360 if (current_thread
== NULL
)
2366 /* Make sure we don't try to read from a trace frame. */
2367 current_traceframe
= -1;
2371 trace_debug ("Initializing the trace");
2373 clear_installed_tracepoints ();
2374 clear_readonly_regions ();
2377 last_tracepoint
= NULL
;
2379 /* Clear out any leftover trace state variables. Ones with target
2380 defined getters should be kept however. */
2382 tsv
= trace_state_variables
;
2385 trace_debug ("Looking at var %d", tsv
->number
);
2386 if (tsv
->getter
== NULL
)
2392 trace_state_variables
= next
;
2393 trace_debug ("Deleting var %d", tsv
->number
);
2404 clear_trace_buffer ();
2405 clear_inferior_trace_buffer ();
2410 /* Unprobe the UST marker at ADDRESS. */
2413 unprobe_marker_at (CORE_ADDR address
)
2415 char cmd
[IPA_CMD_BUF_SIZE
];
2417 sprintf (cmd
, "unprobe_marker_at:%s", paddress (address
));
2418 run_inferior_command (cmd
, strlen (cmd
) + 1);
2421 /* Restore the program to its pre-tracing state. This routine may be called
2422 in error situations, so it needs to be careful about only restoring
2423 from known-valid bits. */
2426 clear_installed_tracepoints (void)
2428 struct tracepoint
*tpoint
;
2429 struct tracepoint
*prev_stpoint
;
2433 prev_stpoint
= NULL
;
2435 /* Restore any bytes overwritten by tracepoints. */
2436 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
2438 /* Catch the case where we might try to remove a tracepoint that
2439 was never actually installed. */
2440 if (tpoint
->handle
== NULL
)
2442 trace_debug ("Tracepoint %d at 0x%s was "
2443 "never installed, nothing to clear",
2444 tpoint
->number
, paddress (tpoint
->address
));
2448 switch (tpoint
->type
)
2450 case trap_tracepoint
:
2452 struct breakpoint
*bp
2453 = (struct breakpoint
*) tpoint
->handle
;
2455 delete_breakpoint (bp
);
2458 case fast_tracepoint
:
2460 struct fast_tracepoint_jump
*jump
2461 = (struct fast_tracepoint_jump
*) tpoint
->handle
;
2463 delete_fast_tracepoint_jump (jump
);
2466 case static_tracepoint
:
2467 if (prev_stpoint
!= NULL
2468 && prev_stpoint
->address
== tpoint
->address
)
2469 /* Nothing to do. We already unprobed a tracepoint set at
2470 this marker address (and there can only be one probe
2475 unprobe_marker_at (tpoint
->address
);
2476 prev_stpoint
= tpoint
;
2481 tpoint
->handle
= NULL
;
2487 /* Parse a packet that defines a tracepoint. */
2490 cmd_qtdp (char *own_buf
)
2493 /* Whether there is a trailing hyphen at the end of the QTDP packet. */
2494 int trail_hyphen
= 0;
2498 struct tracepoint
*tpoint
;
2500 char *packet
= own_buf
;
2502 packet
+= strlen ("QTDP:");
2504 /* A hyphen at the beginning marks a packet specifying actions for a
2505 tracepoint already supplied. */
2512 packet
= unpack_varlen_hex (packet
, &num
);
2513 ++packet
; /* skip a colon */
2514 packet
= unpack_varlen_hex (packet
, &addr
);
2515 ++packet
; /* skip a colon */
2517 /* See if we already have this tracepoint. */
2518 tpoint
= find_tracepoint (num
, addr
);
2522 /* Duplicate tracepoints are never allowed. */
2525 trace_debug ("Tracepoint error: tracepoint %d"
2526 " at 0x%s already exists",
2527 (int) num
, paddress (addr
));
2528 write_enn (own_buf
);
2532 tpoint
= add_tracepoint (num
, addr
);
2534 tpoint
->enabled
= (*packet
== 'E');
2535 ++packet
; /* skip 'E' */
2536 ++packet
; /* skip a colon */
2537 packet
= unpack_varlen_hex (packet
, &count
);
2538 tpoint
->step_count
= count
;
2539 ++packet
; /* skip a colon */
2540 packet
= unpack_varlen_hex (packet
, &count
);
2541 tpoint
->pass_count
= count
;
2542 /* See if we have any of the additional optional fields. */
2543 while (*packet
== ':')
2548 tpoint
->type
= fast_tracepoint
;
2550 packet
= unpack_varlen_hex (packet
, &count
);
2551 tpoint
->orig_size
= count
;
2553 else if (*packet
== 'S')
2555 tpoint
->type
= static_tracepoint
;
2558 else if (*packet
== 'X')
2560 actparm
= (char *) packet
;
2561 tpoint
->cond
= gdb_parse_agent_expr (&actparm
);
2564 else if (*packet
== '-')
2566 else if (*packet
== '\0')
2569 trace_debug ("Unknown optional tracepoint field");
2574 trace_debug ("Also has actions\n");
2577 trace_debug ("Defined %stracepoint %d at 0x%s, "
2578 "enabled %d step %" PRIu64
" pass %" PRIu64
,
2579 tpoint
->type
== fast_tracepoint
? "fast "
2580 : tpoint
->type
== static_tracepoint
? "static " : "",
2581 tpoint
->number
, paddress (tpoint
->address
), tpoint
->enabled
,
2582 tpoint
->step_count
, tpoint
->pass_count
);
2585 add_tracepoint_action (tpoint
, packet
);
2588 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2589 (int) num
, paddress (addr
));
2590 write_enn (own_buf
);
2594 /* Install tracepoint during tracing only once for each tracepoint location.
2595 For each tracepoint loc, GDB may send multiple QTDP packets, and we can
2596 determine the last QTDP packet for one tracepoint location by checking
2597 trailing hyphen in QTDP packet. */
2598 if (tracing
&& !trail_hyphen
)
2600 struct tracepoint
*tp
= NULL
;
2602 /* Pause all threads temporarily while we patch tracepoints. */
2605 /* download_tracepoint will update global `tracepoints'
2606 list, so it is unsafe to leave threads in jump pad. */
2607 stabilize_threads ();
2609 /* Freeze threads. */
2613 if (tpoint
->type
!= trap_tracepoint
)
2615 /* Find another fast or static tracepoint at the same address. */
2616 for (tp
= tracepoints
; tp
; tp
= tp
->next
)
2618 if (tp
->address
== tpoint
->address
&& tp
->type
== tpoint
->type
2619 && tp
->number
!= tpoint
->number
)
2623 /* TPOINT is installed at the same address as TP. */
2626 if (tpoint
->type
== fast_tracepoint
)
2627 clone_fast_tracepoint (tpoint
, tp
);
2628 else if (tpoint
->type
== static_tracepoint
)
2629 tpoint
->handle
= (void *) -1;
2633 if (use_agent
&& tpoint
->type
== fast_tracepoint
2634 && agent_capability_check (AGENT_CAPA_FAST_TRACE
))
2636 /* Download and install fast tracepoint by agent. */
2637 if (tracepoint_send_agent (tpoint
) == 0)
2641 write_enn (own_buf
);
2642 remove_tracepoint (tpoint
);
2647 download_tracepoint (tpoint
);
2649 if (tpoint
->type
== trap_tracepoint
|| tp
== NULL
)
2651 install_tracepoint (tpoint
, own_buf
);
2652 if (strcmp (own_buf
, "OK") != 0)
2653 remove_tracepoint (tpoint
);
2667 cmd_qtdpsrc (char *own_buf
)
2669 ULONGEST num
, addr
, start
, slen
;
2670 struct tracepoint
*tpoint
;
2671 char *packet
= own_buf
;
2672 char *saved
, *srctype
, *src
;
2674 struct source_string
*last
, *newlast
;
2676 packet
+= strlen ("QTDPsrc:");
2678 packet
= unpack_varlen_hex (packet
, &num
);
2679 ++packet
; /* skip a colon */
2680 packet
= unpack_varlen_hex (packet
, &addr
);
2681 ++packet
; /* skip a colon */
2683 /* See if we already have this tracepoint. */
2684 tpoint
= find_tracepoint (num
, addr
);
2688 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2689 (int) num
, paddress (addr
));
2690 write_enn (own_buf
);
2695 packet
= strchr (packet
, ':');
2696 srctype
= (char *) xmalloc (packet
- saved
+ 1);
2697 memcpy (srctype
, saved
, packet
- saved
);
2698 srctype
[packet
- saved
] = '\0';
2700 packet
= unpack_varlen_hex (packet
, &start
);
2701 ++packet
; /* skip a colon */
2702 packet
= unpack_varlen_hex (packet
, &slen
);
2703 ++packet
; /* skip a colon */
2704 src
= (char *) xmalloc (slen
+ 1);
2705 nbytes
= hex2bin (packet
, (gdb_byte
*) src
, strlen (packet
) / 2);
2708 newlast
= XNEW (struct source_string
);
2709 newlast
->type
= srctype
;
2711 newlast
->next
= NULL
;
2712 /* Always add a source string to the end of the list;
2713 this keeps sequences of actions/commands in the right
2715 if (tpoint
->source_strings
)
2717 for (last
= tpoint
->source_strings
; last
->next
; last
= last
->next
)
2719 last
->next
= newlast
;
2722 tpoint
->source_strings
= newlast
;
2728 cmd_qtdv (char *own_buf
)
2730 ULONGEST num
, val
, builtin
;
2733 struct trace_state_variable
*tsv
;
2734 char *packet
= own_buf
;
2736 packet
+= strlen ("QTDV:");
2738 packet
= unpack_varlen_hex (packet
, &num
);
2739 ++packet
; /* skip a colon */
2740 packet
= unpack_varlen_hex (packet
, &val
);
2741 ++packet
; /* skip a colon */
2742 packet
= unpack_varlen_hex (packet
, &builtin
);
2743 ++packet
; /* skip a colon */
2745 nbytes
= strlen (packet
) / 2;
2746 varname
= (char *) xmalloc (nbytes
+ 1);
2747 nbytes
= hex2bin (packet
, (gdb_byte
*) varname
, nbytes
);
2748 varname
[nbytes
] = '\0';
2750 tsv
= create_trace_state_variable (num
, 1);
2751 tsv
->initial_value
= (LONGEST
) val
;
2752 tsv
->name
= varname
;
2754 set_trace_state_variable_value (num
, (LONGEST
) val
);
2760 cmd_qtenable_disable (char *own_buf
, int enable
)
2762 char *packet
= own_buf
;
2764 struct tracepoint
*tp
;
2766 packet
+= strlen (enable
? "QTEnable:" : "QTDisable:");
2767 packet
= unpack_varlen_hex (packet
, &num
);
2768 ++packet
; /* skip a colon */
2769 packet
= unpack_varlen_hex (packet
, &addr
);
2771 tp
= find_tracepoint (num
, addr
);
2775 if ((enable
&& tp
->enabled
) || (!enable
&& !tp
->enabled
))
2777 trace_debug ("Tracepoint %d at 0x%s is already %s",
2778 (int) num
, paddress (addr
),
2779 enable
? "enabled" : "disabled");
2784 trace_debug ("%s tracepoint %d at 0x%s",
2785 enable
? "Enabling" : "Disabling",
2786 (int) num
, paddress (addr
));
2788 tp
->enabled
= enable
;
2790 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
2793 int offset
= offsetof (struct tracepoint
, enabled
);
2794 CORE_ADDR obj_addr
= tp
->obj_addr_on_target
+ offset
;
2796 ret
= prepare_to_access_memory ();
2799 trace_debug ("Failed to temporarily stop inferior threads");
2800 write_enn (own_buf
);
2804 ret
= write_inferior_integer (obj_addr
, enable
);
2805 done_accessing_memory ();
2809 trace_debug ("Cannot write enabled flag into "
2810 "inferior process memory");
2811 write_enn (own_buf
);
2820 trace_debug ("Tracepoint %d at 0x%s not found",
2821 (int) num
, paddress (addr
));
2822 write_enn (own_buf
);
2827 cmd_qtv (char *own_buf
)
2832 char *packet
= own_buf
;
2834 packet
+= strlen ("qTV:");
2835 unpack_varlen_hex (packet
, &num
);
2837 if (current_traceframe
>= 0)
2839 err
= traceframe_read_tsv ((int) num
, &val
);
2842 strcpy (own_buf
, "U");
2846 /* Only make tsv's be undefined before the first trace run. After a
2847 trace run is over, the user might want to see the last value of
2848 the tsv, and it might not be available in a traceframe. */
2849 else if (!tracing
&& strcmp (tracing_stop_reason
, "tnotrun") == 0)
2851 strcpy (own_buf
, "U");
2855 val
= get_trace_state_variable_value (num
);
2857 sprintf (own_buf
, "V%s", phex_nz (val
, 0));
2860 /* Clear out the list of readonly regions. */
2863 clear_readonly_regions (void)
2865 struct readonly_region
*roreg
;
2867 while (readonly_regions
)
2869 roreg
= readonly_regions
;
2870 readonly_regions
= readonly_regions
->next
;
2875 /* Parse the collection of address ranges whose contents GDB believes
2876 to be unchanging and so can be read directly from target memory
2877 even while looking at a traceframe. */
2880 cmd_qtro (char *own_buf
)
2882 ULONGEST start
, end
;
2883 struct readonly_region
*roreg
;
2884 char *packet
= own_buf
;
2886 trace_debug ("Want to mark readonly regions");
2888 clear_readonly_regions ();
2890 packet
+= strlen ("QTro");
2892 while (*packet
== ':')
2894 ++packet
; /* skip a colon */
2895 packet
= unpack_varlen_hex (packet
, &start
);
2896 ++packet
; /* skip a comma */
2897 packet
= unpack_varlen_hex (packet
, &end
);
2899 roreg
= XNEW (struct readonly_region
);
2900 roreg
->start
= start
;
2902 roreg
->next
= readonly_regions
;
2903 readonly_regions
= roreg
;
2904 trace_debug ("Added readonly region from 0x%s to 0x%s",
2905 paddress (roreg
->start
), paddress (roreg
->end
));
2911 /* Test to see if the given range is in our list of readonly ranges.
2912 We only test for being entirely within a range, GDB is not going to
2913 send a single memory packet that spans multiple regions. */
2916 in_readonly_region (CORE_ADDR addr
, ULONGEST length
)
2918 struct readonly_region
*roreg
;
2920 for (roreg
= readonly_regions
; roreg
; roreg
= roreg
->next
)
2921 if (roreg
->start
<= addr
&& (addr
+ length
- 1) <= roreg
->end
)
2927 static CORE_ADDR gdb_jump_pad_head
;
2929 /* Return the address of the next free jump space. */
2932 get_jump_space_head (void)
2934 if (gdb_jump_pad_head
== 0)
2936 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
2937 &gdb_jump_pad_head
))
2939 internal_error (__FILE__
, __LINE__
,
2940 "error extracting jump_pad_buffer");
2944 return gdb_jump_pad_head
;
2947 /* Reserve USED bytes from the jump space. */
2950 claim_jump_space (ULONGEST used
)
2952 trace_debug ("claim_jump_space reserves %s bytes at %s",
2953 pulongest (used
), paddress (gdb_jump_pad_head
));
2954 gdb_jump_pad_head
+= used
;
2957 static CORE_ADDR trampoline_buffer_head
= 0;
2958 static CORE_ADDR trampoline_buffer_tail
;
2960 /* Reserve USED bytes from the trampoline buffer and return the
2961 address of the start of the reserved space in TRAMPOLINE. Returns
2962 non-zero if the space is successfully claimed. */
2965 claim_trampoline_space (ULONGEST used
, CORE_ADDR
*trampoline
)
2967 if (!trampoline_buffer_head
)
2969 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
2970 &trampoline_buffer_tail
))
2972 internal_error (__FILE__
, __LINE__
,
2973 "error extracting trampoline_buffer");
2976 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
2977 &trampoline_buffer_head
))
2979 internal_error (__FILE__
, __LINE__
,
2980 "error extracting trampoline_buffer_end");
2984 /* Start claiming space from the top of the trampoline space. If
2985 the space is located at the bottom of the virtual address space,
2986 this reduces the possibility that corruption will occur if a null
2987 pointer is used to write to memory. */
2988 if (trampoline_buffer_head
- trampoline_buffer_tail
< used
)
2990 trace_debug ("claim_trampoline_space failed to reserve %s bytes",
2995 trampoline_buffer_head
-= used
;
2997 trace_debug ("claim_trampoline_space reserves %s bytes at %s",
2998 pulongest (used
), paddress (trampoline_buffer_head
));
3000 *trampoline
= trampoline_buffer_head
;
3004 /* Returns non-zero if there is space allocated for use in trampolines
3005 for fast tracepoints. */
3008 have_fast_tracepoint_trampoline_buffer (char *buf
)
3010 CORE_ADDR trampoline_end
, errbuf
;
3012 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
3015 internal_error (__FILE__
, __LINE__
,
3016 "error extracting trampoline_buffer_end");
3022 strcpy (buf
, "was claiming");
3023 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_error
,
3026 internal_error (__FILE__
, __LINE__
,
3027 "error extracting errbuf");
3030 read_inferior_memory (errbuf
, (unsigned char *) buf
, 100);
3033 return trampoline_end
!= 0;
3036 /* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
3037 the command fails, or 0 otherwise. If the command ran
3038 successfully, but probing the marker failed, ERROUT will be filled
3039 with the error to reply to GDB, and -1 is also returned. This
3040 allows directly passing IPA errors to GDB. */
3043 probe_marker_at (CORE_ADDR address
, char *errout
)
3045 char cmd
[IPA_CMD_BUF_SIZE
];
3048 sprintf (cmd
, "probe_marker_at:%s", paddress (address
));
3049 err
= run_inferior_command (cmd
, strlen (cmd
) + 1);
3055 strcpy (errout
, cmd
);
3064 clone_fast_tracepoint (struct tracepoint
*to
, const struct tracepoint
*from
)
3066 to
->jump_pad
= from
->jump_pad
;
3067 to
->jump_pad_end
= from
->jump_pad_end
;
3068 to
->trampoline
= from
->trampoline
;
3069 to
->trampoline_end
= from
->trampoline_end
;
3070 to
->adjusted_insn_addr
= from
->adjusted_insn_addr
;
3071 to
->adjusted_insn_addr_end
= from
->adjusted_insn_addr_end
;
3072 to
->handle
= from
->handle
;
3074 gdb_assert (from
->handle
);
3075 inc_ref_fast_tracepoint_jump ((struct fast_tracepoint_jump
*) from
->handle
);
3078 #define MAX_JUMP_SIZE 20
3080 /* Install fast tracepoint. Return 0 if successful, otherwise return
3084 install_fast_tracepoint (struct tracepoint
*tpoint
, char *errbuf
)
3086 CORE_ADDR jentry
, jump_entry
;
3087 CORE_ADDR trampoline
;
3088 ULONGEST trampoline_size
;
3090 /* The jump to the jump pad of the last fast tracepoint
3092 unsigned char fjump
[MAX_JUMP_SIZE
];
3093 ULONGEST fjump_size
;
3095 if (tpoint
->orig_size
< target_get_min_fast_tracepoint_insn_len ())
3097 trace_debug ("Requested a fast tracepoint on an instruction "
3098 "that is of less than the minimum length.");
3102 jentry
= jump_entry
= get_jump_space_head ();
3105 trampoline_size
= 0;
3107 /* Install the jump pad. */
3108 err
= install_fast_tracepoint_jump_pad (tpoint
->obj_addr_on_target
,
3110 ipa_sym_addrs
.addr_gdb_collect
,
3111 ipa_sym_addrs
.addr_collecting
,
3114 &trampoline
, &trampoline_size
,
3116 &tpoint
->adjusted_insn_addr
,
3117 &tpoint
->adjusted_insn_addr_end
,
3124 tpoint
->handle
= set_fast_tracepoint_jump (tpoint
->address
, fjump
,
3127 if (tpoint
->handle
!= NULL
)
3129 tpoint
->jump_pad
= jump_entry
;
3130 tpoint
->jump_pad_end
= jentry
;
3131 tpoint
->trampoline
= trampoline
;
3132 tpoint
->trampoline_end
= trampoline
+ trampoline_size
;
3134 /* Pad to 8-byte alignment. */
3135 jentry
= ((jentry
+ 7) & ~0x7);
3136 claim_jump_space (jentry
- jump_entry
);
3143 /* Install tracepoint TPOINT, and write reply message in OWN_BUF. */
3146 install_tracepoint (struct tracepoint
*tpoint
, char *own_buf
)
3148 tpoint
->handle
= NULL
;
3151 if (tpoint
->type
== trap_tracepoint
)
3153 /* Tracepoints are installed as memory breakpoints. Just go
3154 ahead and install the trap. The breakpoints module
3155 handles duplicated breakpoints, and the memory read
3156 routine handles un-patching traps from memory reads. */
3157 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3158 tracepoint_handler
);
3160 else if (tpoint
->type
== fast_tracepoint
|| tpoint
->type
== static_tracepoint
)
3162 if (!agent_loaded_p ())
3164 trace_debug ("Requested a %s tracepoint, but fast "
3165 "tracepoints aren't supported.",
3166 tpoint
->type
== static_tracepoint
? "static" : "fast");
3167 write_e_ipa_not_loaded (own_buf
);
3170 if (tpoint
->type
== static_tracepoint
3171 && !in_process_agent_supports_ust ())
3173 trace_debug ("Requested a static tracepoint, but static "
3174 "tracepoints are not supported.");
3175 write_e_ust_not_loaded (own_buf
);
3179 if (tpoint
->type
== fast_tracepoint
)
3180 install_fast_tracepoint (tpoint
, own_buf
);
3183 if (probe_marker_at (tpoint
->address
, own_buf
) == 0)
3184 tpoint
->handle
= (void *) -1;
3189 internal_error (__FILE__
, __LINE__
, "Unknown tracepoint type");
3191 if (tpoint
->handle
== NULL
)
3193 if (*own_buf
== '\0')
3194 write_enn (own_buf
);
3200 static void download_tracepoint_1 (struct tracepoint
*tpoint
);
3203 cmd_qtstart (char *packet
)
3205 struct tracepoint
*tpoint
, *prev_ftpoint
, *prev_stpoint
;
3206 CORE_ADDR tpptr
= 0, prev_tpptr
= 0;
3208 trace_debug ("Starting the trace");
3210 /* Pause all threads temporarily while we patch tracepoints. */
3213 /* Get threads out of jump pads. Safe to do here, since this is a
3214 top level command. And, required to do here, since we're
3215 deleting/rewriting jump pads. */
3217 stabilize_threads ();
3219 /* Freeze threads. */
3222 /* Sync the fast tracepoints list in the inferior ftlib. */
3223 if (agent_loaded_p ())
3224 download_trace_state_variables ();
3226 /* No previous fast tpoint yet. */
3227 prev_ftpoint
= NULL
;
3229 /* No previous static tpoint yet. */
3230 prev_stpoint
= NULL
;
3234 /* Start out empty. */
3235 if (agent_loaded_p ())
3236 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, 0);
3238 /* Download and install tracepoints. */
3239 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
3241 /* Ensure all the hit counts start at zero. */
3242 tpoint
->hit_count
= 0;
3243 tpoint
->traceframe_usage
= 0;
3245 if (tpoint
->type
== trap_tracepoint
)
3247 /* Tracepoints are installed as memory breakpoints. Just go
3248 ahead and install the trap. The breakpoints module
3249 handles duplicated breakpoints, and the memory read
3250 routine handles un-patching traps from memory reads. */
3251 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
3252 tracepoint_handler
);
3254 else if (tpoint
->type
== fast_tracepoint
3255 || tpoint
->type
== static_tracepoint
)
3257 if (maybe_write_ipa_not_loaded (packet
))
3259 trace_debug ("Requested a %s tracepoint, but fast "
3260 "tracepoints aren't supported.",
3261 tpoint
->type
== static_tracepoint
3262 ? "static" : "fast");
3266 if (tpoint
->type
== fast_tracepoint
)
3269 = use_agent
&& agent_capability_check (AGENT_CAPA_FAST_TRACE
);
3271 if (prev_ftpoint
!= NULL
3272 && prev_ftpoint
->address
== tpoint
->address
)
3275 tracepoint_send_agent (tpoint
);
3277 download_tracepoint_1 (tpoint
);
3279 clone_fast_tracepoint (tpoint
, prev_ftpoint
);
3283 /* Tracepoint is installed successfully? */
3286 /* Download and install fast tracepoint by agent. */
3288 installed
= !tracepoint_send_agent (tpoint
);
3291 download_tracepoint_1 (tpoint
);
3292 installed
= !install_fast_tracepoint (tpoint
, packet
);
3296 prev_ftpoint
= tpoint
;
3301 if (!in_process_agent_supports_ust ())
3303 trace_debug ("Requested a static tracepoint, but static "
3304 "tracepoints are not supported.");
3308 download_tracepoint_1 (tpoint
);
3309 /* Can only probe a given marker once. */
3310 if (prev_stpoint
!= NULL
3311 && prev_stpoint
->address
== tpoint
->address
)
3312 tpoint
->handle
= (void *) -1;
3315 if (probe_marker_at (tpoint
->address
, packet
) == 0)
3317 tpoint
->handle
= (void *) -1;
3319 /* So that we can handle multiple static tracepoints
3320 at the same address easily. */
3321 prev_stpoint
= tpoint
;
3327 tpptr
= tpoint
->obj_addr_on_target
;
3329 if (tpoint
== tracepoints
)
3330 /* First object in list, set the head pointer in the
3332 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, tpptr
);
3334 write_inferior_data_ptr (prev_tpptr
+ offsetof (struct tracepoint
,
3339 /* Any failure in the inner loop is sufficient cause to give
3341 if (tpoint
->handle
== NULL
)
3345 /* Any error in tracepoint insertion is unacceptable; better to
3346 address the problem now, than end up with a useless or misleading
3350 clear_installed_tracepoints ();
3351 if (*packet
== '\0')
3357 stopping_tracepoint
= NULL
;
3358 trace_buffer_is_full
= 0;
3359 expr_eval_result
= expr_eval_no_error
;
3360 error_tracepoint
= NULL
;
3361 tracing_start_time
= get_timestamp ();
3363 /* Tracing is now active, hits will now start being logged. */
3366 if (agent_loaded_p ())
3368 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 1))
3370 internal_error (__FILE__
, __LINE__
,
3371 "Error setting tracing variable in lib");
3374 if (write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
3377 internal_error (__FILE__
, __LINE__
,
3378 "Error clearing stopping_tracepoint variable"
3382 if (write_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
, 0))
3384 internal_error (__FILE__
, __LINE__
,
3385 "Error clearing trace_buffer_is_full variable"
3389 stop_tracing_bkpt
= set_breakpoint_at (ipa_sym_addrs
.addr_stop_tracing
,
3390 stop_tracing_handler
);
3391 if (stop_tracing_bkpt
== NULL
)
3392 error ("Error setting stop_tracing breakpoint");
3394 flush_trace_buffer_bkpt
3395 = set_breakpoint_at (ipa_sym_addrs
.addr_flush_trace_buffer
,
3396 flush_trace_buffer_handler
);
3397 if (flush_trace_buffer_bkpt
== NULL
)
3398 error ("Error setting flush_trace_buffer breakpoint");
3406 /* End a tracing run, filling in a stop reason to report back to GDB,
3407 and removing the tracepoints from the code. */
3414 trace_debug ("Tracing is already off, ignoring");
3418 trace_debug ("Stopping the trace");
3420 /* Pause all threads before removing fast jumps from memory,
3421 breakpoints, and touching IPA state variables (inferior memory).
3422 Some thread may hit the internal tracing breakpoints, or be
3423 collecting this moment, but that's ok, we don't release the
3424 tpoint object's memory or the jump pads here (we only do that
3425 when we're sure we can move all threads out of the jump pads).
3426 We can't now, since we may be getting here due to the inferior
3427 agent calling us. */
3430 /* Stop logging. Tracepoints can still be hit, but they will not be
3433 if (agent_loaded_p ())
3435 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 0))
3437 internal_error (__FILE__
, __LINE__
,
3438 "Error clearing tracing variable in lib");
3442 tracing_stop_time
= get_timestamp ();
3443 tracing_stop_reason
= "t???";
3444 tracing_stop_tpnum
= 0;
3445 if (stopping_tracepoint
)
3447 trace_debug ("Stopping the trace because "
3448 "tracepoint %d was hit %" PRIu64
" times",
3449 stopping_tracepoint
->number
,
3450 stopping_tracepoint
->pass_count
);
3451 tracing_stop_reason
= "tpasscount";
3452 tracing_stop_tpnum
= stopping_tracepoint
->number
;
3454 else if (trace_buffer_is_full
)
3456 trace_debug ("Stopping the trace because the trace buffer is full");
3457 tracing_stop_reason
= "tfull";
3459 else if (expr_eval_result
!= expr_eval_no_error
)
3461 trace_debug ("Stopping the trace because of an expression eval error");
3462 tracing_stop_reason
= eval_result_names
[expr_eval_result
];
3463 tracing_stop_tpnum
= error_tracepoint
->number
;
3465 #ifndef IN_PROCESS_AGENT
3466 else if (!gdb_connected ())
3468 trace_debug ("Stopping the trace because GDB disconnected");
3469 tracing_stop_reason
= "tdisconnected";
3474 trace_debug ("Stopping the trace because of a tstop command");
3475 tracing_stop_reason
= "tstop";
3478 stopping_tracepoint
= NULL
;
3479 error_tracepoint
= NULL
;
3481 /* Clear out the tracepoints. */
3482 clear_installed_tracepoints ();
3484 if (agent_loaded_p ())
3486 /* Pull in fast tracepoint trace frames from the inferior lib
3487 buffer into our buffer, even if our buffer is already full,
3488 because we want to present the full number of created frames
3489 in addition to what fit in the trace buffer. */
3490 upload_fast_traceframes ();
3493 if (stop_tracing_bkpt
!= NULL
)
3495 delete_breakpoint (stop_tracing_bkpt
);
3496 stop_tracing_bkpt
= NULL
;
3499 if (flush_trace_buffer_bkpt
!= NULL
)
3501 delete_breakpoint (flush_trace_buffer_bkpt
);
3502 flush_trace_buffer_bkpt
= NULL
;
3509 stop_tracing_handler (CORE_ADDR addr
)
3511 trace_debug ("lib hit stop_tracing");
3513 /* Don't actually handle it here. When we stop tracing we remove
3514 breakpoints from the inferior, and that is not allowed in a
3515 breakpoint handler (as the caller is walking the breakpoint
3521 flush_trace_buffer_handler (CORE_ADDR addr
)
3523 trace_debug ("lib hit flush_trace_buffer");
3528 cmd_qtstop (char *packet
)
3535 cmd_qtdisconnected (char *own_buf
)
3538 char *packet
= own_buf
;
3540 packet
+= strlen ("QTDisconnected:");
3542 unpack_varlen_hex (packet
, &setting
);
3546 disconnected_tracing
= setting
;
3550 cmd_qtframe (char *own_buf
)
3552 ULONGEST frame
, pc
, lo
, hi
, num
;
3554 struct traceframe
*tframe
;
3555 char *packet
= own_buf
;
3557 packet
+= strlen ("QTFrame:");
3559 if (startswith (packet
, "pc:"))
3561 packet
+= strlen ("pc:");
3562 unpack_varlen_hex (packet
, &pc
);
3563 trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc
));
3564 tframe
= find_next_traceframe_in_range (pc
, pc
, 1, &tfnum
);
3566 else if (startswith (packet
, "range:"))
3568 packet
+= strlen ("range:");
3569 packet
= unpack_varlen_hex (packet
, &lo
);
3571 unpack_varlen_hex (packet
, &hi
);
3572 trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s",
3573 paddress (lo
), paddress (hi
));
3574 tframe
= find_next_traceframe_in_range (lo
, hi
, 1, &tfnum
);
3576 else if (startswith (packet
, "outside:"))
3578 packet
+= strlen ("outside:");
3579 packet
= unpack_varlen_hex (packet
, &lo
);
3581 unpack_varlen_hex (packet
, &hi
);
3582 trace_debug ("Want to find next traceframe "
3583 "outside the range 0x%s to 0x%s",
3584 paddress (lo
), paddress (hi
));
3585 tframe
= find_next_traceframe_in_range (lo
, hi
, 0, &tfnum
);
3587 else if (startswith (packet
, "tdp:"))
3589 packet
+= strlen ("tdp:");
3590 unpack_varlen_hex (packet
, &num
);
3592 trace_debug ("Want to find next traceframe for tracepoint %d", tpnum
);
3593 tframe
= find_next_traceframe_by_tracepoint (tpnum
, &tfnum
);
3597 unpack_varlen_hex (packet
, &frame
);
3598 tfnum
= (int) frame
;
3601 trace_debug ("Want to stop looking at traceframes");
3602 current_traceframe
= -1;
3606 trace_debug ("Want to look at traceframe %d", tfnum
);
3607 tframe
= find_traceframe (tfnum
);
3612 current_traceframe
= tfnum
;
3613 sprintf (own_buf
, "F%xT%x", tfnum
, tframe
->tpnum
);
3616 sprintf (own_buf
, "F-1");
3620 cmd_qtstatus (char *packet
)
3622 char *stop_reason_rsp
= NULL
;
3623 char *buf1
, *buf2
, *buf3
;
3627 /* Translate the plain text of the notes back into hex for
3630 str
= (tracing_user_name
? tracing_user_name
: "");
3631 slen
= strlen (str
);
3632 buf1
= (char *) alloca (slen
* 2 + 1);
3633 bin2hex ((gdb_byte
*) str
, buf1
, slen
);
3635 str
= (tracing_notes
? tracing_notes
: "");
3636 slen
= strlen (str
);
3637 buf2
= (char *) alloca (slen
* 2 + 1);
3638 bin2hex ((gdb_byte
*) str
, buf2
, slen
);
3640 str
= (tracing_stop_note
? tracing_stop_note
: "");
3641 slen
= strlen (str
);
3642 buf3
= (char *) alloca (slen
* 2 + 1);
3643 bin2hex ((gdb_byte
*) str
, buf3
, slen
);
3645 trace_debug ("Returning trace status as %d, stop reason %s",
3646 tracing
, tracing_stop_reason
);
3648 if (agent_loaded_p ())
3652 upload_fast_traceframes ();
3657 stop_reason_rsp
= (char *) tracing_stop_reason
;
3659 /* The user visible error string in terror needs to be hex encoded.
3660 We leave it as plain string in `tracing_stop_reason' to ease
3662 if (startswith (stop_reason_rsp
, "terror:"))
3664 const char *result_name
;
3668 result_name
= stop_reason_rsp
+ strlen ("terror:");
3669 hexstr_len
= strlen (result_name
) * 2;
3671 = (char *) alloca (strlen ("terror:") + hexstr_len
+ 1);
3672 strcpy (p
, "terror:");
3674 bin2hex ((gdb_byte
*) result_name
, p
, strlen (result_name
));
3677 /* If this was a forced stop, include any stop note that was supplied. */
3678 if (strcmp (stop_reason_rsp
, "tstop") == 0)
3680 stop_reason_rsp
= (char *) alloca (strlen ("tstop:") + strlen (buf3
) + 1);
3681 strcpy (stop_reason_rsp
, "tstop:");
3682 strcat (stop_reason_rsp
, buf3
);
3688 "tframes:%x;tcreated:%x;"
3689 "tfree:%x;tsize:%s;"
3692 "starttime:%s;stoptime:%s;"
3693 "username:%s;notes:%s:",
3695 stop_reason_rsp
, tracing_stop_tpnum
,
3696 traceframe_count
, traceframes_created
,
3697 free_space (), phex_nz (trace_buffer_hi
- trace_buffer_lo
, 0),
3698 circular_trace_buffer
,
3699 disconnected_tracing
,
3700 phex_nz (tracing_start_time
, sizeof (tracing_start_time
)),
3701 phex_nz (tracing_stop_time
, sizeof (tracing_stop_time
)),
3706 cmd_qtp (char *own_buf
)
3709 struct tracepoint
*tpoint
;
3710 char *packet
= own_buf
;
3712 packet
+= strlen ("qTP:");
3714 packet
= unpack_varlen_hex (packet
, &num
);
3715 ++packet
; /* skip a colon */
3716 packet
= unpack_varlen_hex (packet
, &addr
);
3718 /* See if we already have this tracepoint. */
3719 tpoint
= find_tracepoint (num
, addr
);
3723 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
3724 (int) num
, paddress (addr
));
3725 write_enn (own_buf
);
3729 sprintf (own_buf
, "V%" PRIu64
":%" PRIu64
"", tpoint
->hit_count
,
3730 tpoint
->traceframe_usage
);
3733 /* State variables to help return all the tracepoint bits. */
3734 static struct tracepoint
*cur_tpoint
;
3735 static unsigned int cur_action
;
3736 static unsigned int cur_step_action
;
3737 static struct source_string
*cur_source_string
;
3738 static struct trace_state_variable
*cur_tsv
;
3740 /* Compose a response that is an imitation of the syntax by which the
3741 tracepoint was originally downloaded. */
3744 response_tracepoint (char *packet
, struct tracepoint
*tpoint
)
3748 sprintf (packet
, "T%x:%s:%c:%" PRIx64
":%" PRIx64
, tpoint
->number
,
3749 paddress (tpoint
->address
),
3750 (tpoint
->enabled
? 'E' : 'D'), tpoint
->step_count
,
3751 tpoint
->pass_count
);
3752 if (tpoint
->type
== fast_tracepoint
)
3753 sprintf (packet
+ strlen (packet
), ":F%x", tpoint
->orig_size
);
3754 else if (tpoint
->type
== static_tracepoint
)
3755 sprintf (packet
+ strlen (packet
), ":S");
3759 buf
= gdb_unparse_agent_expr (tpoint
->cond
);
3760 sprintf (packet
+ strlen (packet
), ":X%x,%s",
3761 tpoint
->cond
->length
, buf
);
3766 /* Compose a response that is an imitation of the syntax by which the
3767 tracepoint action was originally downloaded (with the difference
3768 that due to the way we store the actions, this will output a packet
3769 per action, while GDB could have combined more than one action
3773 response_action (char *packet
, struct tracepoint
*tpoint
,
3774 char *taction
, int step
)
3776 sprintf (packet
, "%c%x:%s:%s",
3777 (step
? 'S' : 'A'), tpoint
->number
, paddress (tpoint
->address
),
3781 /* Compose a response that is an imitation of the syntax by which the
3782 tracepoint source piece was originally downloaded. */
3785 response_source (char *packet
,
3786 struct tracepoint
*tpoint
, struct source_string
*src
)
3791 len
= strlen (src
->str
);
3792 buf
= (char *) alloca (len
* 2 + 1);
3793 bin2hex ((gdb_byte
*) src
->str
, buf
, len
);
3795 sprintf (packet
, "Z%x:%s:%s:%x:%x:%s",
3796 tpoint
->number
, paddress (tpoint
->address
),
3797 src
->type
, 0, len
, buf
);
3800 /* Return the first piece of tracepoint definition, and initialize the
3801 state machine that will iterate through all the tracepoint
3805 cmd_qtfp (char *packet
)
3807 trace_debug ("Returning first tracepoint definition piece");
3809 cur_tpoint
= tracepoints
;
3810 cur_action
= cur_step_action
= 0;
3811 cur_source_string
= NULL
;
3814 response_tracepoint (packet
, cur_tpoint
);
3816 strcpy (packet
, "l");
3819 /* Return additional pieces of tracepoint definition. Each action and
3820 stepping action must go into its own packet, because of packet size
3821 limits, and so we use state variables to deliver one piece at a
3825 cmd_qtsp (char *packet
)
3827 trace_debug ("Returning subsequent tracepoint definition piece");
3831 /* This case would normally never occur, but be prepared for
3833 strcpy (packet
, "l");
3835 else if (cur_action
< cur_tpoint
->numactions
)
3837 response_action (packet
, cur_tpoint
,
3838 cur_tpoint
->actions_str
[cur_action
], 0);
3841 else if (cur_step_action
< cur_tpoint
->num_step_actions
)
3843 response_action (packet
, cur_tpoint
,
3844 cur_tpoint
->step_actions_str
[cur_step_action
], 1);
3847 else if ((cur_source_string
3848 ? cur_source_string
->next
3849 : cur_tpoint
->source_strings
))
3851 if (cur_source_string
)
3852 cur_source_string
= cur_source_string
->next
;
3854 cur_source_string
= cur_tpoint
->source_strings
;
3855 response_source (packet
, cur_tpoint
, cur_source_string
);
3859 cur_tpoint
= cur_tpoint
->next
;
3860 cur_action
= cur_step_action
= 0;
3861 cur_source_string
= NULL
;
3863 response_tracepoint (packet
, cur_tpoint
);
3865 strcpy (packet
, "l");
3869 /* Compose a response that is an imitation of the syntax by which the
3870 trace state variable was originally downloaded. */
3873 response_tsv (char *packet
, struct trace_state_variable
*tsv
)
3875 char *buf
= (char *) "";
3880 namelen
= strlen (tsv
->name
);
3881 buf
= (char *) alloca (namelen
* 2 + 1);
3882 bin2hex ((gdb_byte
*) tsv
->name
, buf
, namelen
);
3885 sprintf (packet
, "%x:%s:%x:%s", tsv
->number
, phex_nz (tsv
->initial_value
, 0),
3886 tsv
->getter
? 1 : 0, buf
);
3889 /* Return the first trace state variable definition, and initialize
3890 the state machine that will iterate through all the tsv bits. */
3893 cmd_qtfv (char *packet
)
3895 trace_debug ("Returning first trace state variable definition");
3897 cur_tsv
= trace_state_variables
;
3900 response_tsv (packet
, cur_tsv
);
3902 strcpy (packet
, "l");
3905 /* Return additional trace state variable definitions. */
3908 cmd_qtsv (char *packet
)
3910 trace_debug ("Returning additional trace state variable definition");
3914 cur_tsv
= cur_tsv
->next
;
3916 response_tsv (packet
, cur_tsv
);
3918 strcpy (packet
, "l");
3921 strcpy (packet
, "l");
3924 /* Return the first static tracepoint marker, and initialize the state
3925 machine that will iterate through all the static tracepoints
3929 cmd_qtfstm (char *packet
)
3931 if (!maybe_write_ipa_ust_not_loaded (packet
))
3932 run_inferior_command (packet
, strlen (packet
) + 1);
3935 /* Return additional static tracepoints markers. */
3938 cmd_qtsstm (char *packet
)
3940 if (!maybe_write_ipa_ust_not_loaded (packet
))
3941 run_inferior_command (packet
, strlen (packet
) + 1);
3944 /* Return the definition of the static tracepoint at a given address.
3945 Result packet is the same as qTsST's. */
3948 cmd_qtstmat (char *packet
)
3950 if (!maybe_write_ipa_ust_not_loaded (packet
))
3951 run_inferior_command (packet
, strlen (packet
) + 1);
3954 /* Helper for gdb_agent_about_to_close.
3955 Return non-zero if thread ENTRY is in the same process in DATA. */
3958 same_process_p (struct inferior_list_entry
*entry
, void *data
)
3960 int *pid
= (int *) data
;
3962 return ptid_get_pid (entry
->id
) == *pid
;
3965 /* Sent the agent a command to close it. */
3968 gdb_agent_about_to_close (int pid
)
3970 char buf
[IPA_CMD_BUF_SIZE
];
3972 if (!maybe_write_ipa_not_loaded (buf
))
3974 struct thread_info
*saved_thread
;
3976 saved_thread
= current_thread
;
3978 /* Find any thread which belongs to process PID. */
3979 current_thread
= (struct thread_info
*)
3980 find_inferior (&all_threads
, same_process_p
, &pid
);
3982 strcpy (buf
, "close");
3984 run_inferior_command (buf
, strlen (buf
) + 1);
3986 current_thread
= saved_thread
;
3990 /* Return the minimum instruction size needed for fast tracepoints as a
3991 hexadecimal number. */
3994 cmd_qtminftpilen (char *packet
)
3996 if (current_thread
== NULL
)
3998 /* Indicate that the minimum length is currently unknown. */
3999 strcpy (packet
, "0");
4003 sprintf (packet
, "%x", target_get_min_fast_tracepoint_insn_len ());
4006 /* Respond to qTBuffer packet with a block of raw data from the trace
4007 buffer. GDB may ask for a lot, but we are allowed to reply with
4008 only as much as will fit within packet limits or whatever. */
4011 cmd_qtbuffer (char *own_buf
)
4013 ULONGEST offset
, num
, tot
;
4015 char *packet
= own_buf
;
4017 packet
+= strlen ("qTBuffer:");
4019 packet
= unpack_varlen_hex (packet
, &offset
);
4020 ++packet
; /* skip a comma */
4021 unpack_varlen_hex (packet
, &num
);
4023 trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s",
4024 (int) num
, phex_nz (offset
, 0));
4026 tot
= (trace_buffer_hi
- trace_buffer_lo
) - free_space ();
4028 /* If we're right at the end, reply specially that we're done. */
4031 strcpy (own_buf
, "l");
4035 /* Object to any other out-of-bounds request. */
4038 write_enn (own_buf
);
4042 /* Compute the pointer corresponding to the given offset, accounting
4044 tbp
= trace_buffer_start
+ offset
;
4045 if (tbp
>= trace_buffer_wrap
)
4046 tbp
-= (trace_buffer_wrap
- trace_buffer_lo
);
4048 /* Trim to the remaining bytes if we're close to the end. */
4049 if (num
> tot
- offset
)
4052 /* Trim to available packet size. */
4053 if (num
>= (PBUFSIZ
- 16) / 2 )
4054 num
= (PBUFSIZ
- 16) / 2;
4056 bin2hex (tbp
, own_buf
, num
);
4060 cmd_bigqtbuffer_circular (char *own_buf
)
4063 char *packet
= own_buf
;
4065 packet
+= strlen ("QTBuffer:circular:");
4067 unpack_varlen_hex (packet
, &val
);
4068 circular_trace_buffer
= val
;
4069 trace_debug ("Trace buffer is now %s",
4070 circular_trace_buffer
? "circular" : "linear");
4075 cmd_bigqtbuffer_size (char *own_buf
)
4079 char *packet
= own_buf
;
4081 /* Can't change the size during a tracing run. */
4084 write_enn (own_buf
);
4088 packet
+= strlen ("QTBuffer:size:");
4090 /* -1 is sent as literal "-1". */
4091 if (strcmp (packet
, "-1") == 0)
4092 sval
= DEFAULT_TRACE_BUFFER_SIZE
;
4095 unpack_varlen_hex (packet
, &val
);
4096 sval
= (LONGEST
) val
;
4099 init_trace_buffer (sval
);
4100 trace_debug ("Trace buffer is now %s bytes",
4101 plongest (trace_buffer_size
));
4106 cmd_qtnotes (char *own_buf
)
4109 char *saved
, *user
, *notes
, *stopnote
;
4110 char *packet
= own_buf
;
4112 packet
+= strlen ("QTNotes:");
4116 if (startswith (packet
, "user:"))
4118 packet
+= strlen ("user:");
4120 packet
= strchr (packet
, ';');
4121 nbytes
= (packet
- saved
) / 2;
4122 user
= (char *) xmalloc (nbytes
+ 1);
4123 nbytes
= hex2bin (saved
, (gdb_byte
*) user
, nbytes
);
4124 user
[nbytes
] = '\0';
4125 ++packet
; /* skip the semicolon */
4126 trace_debug ("User is '%s'", user
);
4127 xfree (tracing_user_name
);
4128 tracing_user_name
= user
;
4130 else if (startswith (packet
, "notes:"))
4132 packet
+= strlen ("notes:");
4134 packet
= strchr (packet
, ';');
4135 nbytes
= (packet
- saved
) / 2;
4136 notes
= (char *) xmalloc (nbytes
+ 1);
4137 nbytes
= hex2bin (saved
, (gdb_byte
*) notes
, nbytes
);
4138 notes
[nbytes
] = '\0';
4139 ++packet
; /* skip the semicolon */
4140 trace_debug ("Notes is '%s'", notes
);
4141 xfree (tracing_notes
);
4142 tracing_notes
= notes
;
4144 else if (startswith (packet
, "tstop:"))
4146 packet
+= strlen ("tstop:");
4148 packet
= strchr (packet
, ';');
4149 nbytes
= (packet
- saved
) / 2;
4150 stopnote
= (char *) xmalloc (nbytes
+ 1);
4151 nbytes
= hex2bin (saved
, (gdb_byte
*) stopnote
, nbytes
);
4152 stopnote
[nbytes
] = '\0';
4153 ++packet
; /* skip the semicolon */
4154 trace_debug ("tstop note is '%s'", stopnote
);
4155 xfree (tracing_stop_note
);
4156 tracing_stop_note
= stopnote
;
4166 handle_tracepoint_general_set (char *packet
)
4168 if (strcmp ("QTinit", packet
) == 0)
4170 cmd_qtinit (packet
);
4173 else if (startswith (packet
, "QTDP:"))
4178 else if (startswith (packet
, "QTDPsrc:"))
4180 cmd_qtdpsrc (packet
);
4183 else if (startswith (packet
, "QTEnable:"))
4185 cmd_qtenable_disable (packet
, 1);
4188 else if (startswith (packet
, "QTDisable:"))
4190 cmd_qtenable_disable (packet
, 0);
4193 else if (startswith (packet
, "QTDV:"))
4198 else if (startswith (packet
, "QTro:"))
4203 else if (strcmp ("QTStart", packet
) == 0)
4205 cmd_qtstart (packet
);
4208 else if (strcmp ("QTStop", packet
) == 0)
4210 cmd_qtstop (packet
);
4213 else if (startswith (packet
, "QTDisconnected:"))
4215 cmd_qtdisconnected (packet
);
4218 else if (startswith (packet
, "QTFrame:"))
4220 cmd_qtframe (packet
);
4223 else if (startswith (packet
, "QTBuffer:circular:"))
4225 cmd_bigqtbuffer_circular (packet
);
4228 else if (startswith (packet
, "QTBuffer:size:"))
4230 cmd_bigqtbuffer_size (packet
);
4233 else if (startswith (packet
, "QTNotes:"))
4235 cmd_qtnotes (packet
);
4243 handle_tracepoint_query (char *packet
)
4245 if (strcmp ("qTStatus", packet
) == 0)
4247 cmd_qtstatus (packet
);
4250 else if (startswith (packet
, "qTP:"))
4255 else if (strcmp ("qTfP", packet
) == 0)
4260 else if (strcmp ("qTsP", packet
) == 0)
4265 else if (strcmp ("qTfV", packet
) == 0)
4270 else if (strcmp ("qTsV", packet
) == 0)
4275 else if (startswith (packet
, "qTV:"))
4280 else if (startswith (packet
, "qTBuffer:"))
4282 cmd_qtbuffer (packet
);
4285 else if (strcmp ("qTfSTM", packet
) == 0)
4287 cmd_qtfstm (packet
);
4290 else if (strcmp ("qTsSTM", packet
) == 0)
4292 cmd_qtsstm (packet
);
4295 else if (startswith (packet
, "qTSTMat:"))
4297 cmd_qtstmat (packet
);
4300 else if (strcmp ("qTMinFTPILen", packet
) == 0)
4302 cmd_qtminftpilen (packet
);
4310 #ifndef IN_PROCESS_AGENT
4312 /* Call this when thread TINFO has hit the tracepoint defined by
4313 TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping
4314 action. This adds a while-stepping collecting state item to the
4315 threads' collecting state list, so that we can keep track of
4316 multiple simultaneous while-stepping actions being collected by the
4317 same thread. This can happen in cases like:
4319 ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs
4321 ff0003 INSN3 <-- TP2, collect $regs
4322 ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs
4325 Notice that when instruction INSN5 is reached, the while-stepping
4326 actions of both TP1 and TP3 are still being collected, and that TP2
4327 had been collected meanwhile. The whole range of ff0001-ff0005
4328 should be single-stepped, due to at least TP1's while-stepping
4329 action covering the whole range. */
4332 add_while_stepping_state (struct thread_info
*tinfo
,
4333 int tp_number
, CORE_ADDR tp_address
)
4335 struct wstep_state
*wstep
= XNEW (struct wstep_state
);
4337 wstep
->next
= tinfo
->while_stepping
;
4339 wstep
->tp_number
= tp_number
;
4340 wstep
->tp_address
= tp_address
;
4341 wstep
->current_step
= 0;
4343 tinfo
->while_stepping
= wstep
;
4346 /* Release the while-stepping collecting state WSTEP. */
4349 release_while_stepping_state (struct wstep_state
*wstep
)
4354 /* Release all while-stepping collecting states currently associated
4355 with thread TINFO. */
4358 release_while_stepping_state_list (struct thread_info
*tinfo
)
4360 struct wstep_state
*head
;
4362 while (tinfo
->while_stepping
)
4364 head
= tinfo
->while_stepping
;
4365 tinfo
->while_stepping
= head
->next
;
4366 release_while_stepping_state (head
);
4370 /* If TINFO was handling a 'while-stepping' action, the step has
4371 finished, so collect any step data needed, and check if any more
4372 steps are required. Return true if the thread was indeed
4373 collecting tracepoint data, false otherwise. */
4376 tracepoint_finished_step (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4378 struct tracepoint
*tpoint
;
4379 struct wstep_state
*wstep
;
4380 struct wstep_state
**wstep_link
;
4381 struct trap_tracepoint_ctx ctx
;
4383 /* Pull in fast tracepoint trace frames from the inferior lib buffer into
4385 if (agent_loaded_p ())
4386 upload_fast_traceframes ();
4388 /* Check if we were indeed collecting data for one of more
4389 tracepoints with a 'while-stepping' count. */
4390 if (tinfo
->while_stepping
== NULL
)
4395 /* We're not even tracing anymore. Stop this thread from
4397 release_while_stepping_state_list (tinfo
);
4399 /* The thread had stopped due to a single-step request indeed
4400 explained by a tracepoint. */
4404 wstep
= tinfo
->while_stepping
;
4405 wstep_link
= &tinfo
->while_stepping
;
4407 trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
4408 target_pid_to_str (tinfo
->entry
.id
),
4409 wstep
->tp_number
, paddress (wstep
->tp_address
));
4411 ctx
.base
.type
= trap_tracepoint
;
4412 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4414 while (wstep
!= NULL
)
4416 tpoint
= find_tracepoint (wstep
->tp_number
, wstep
->tp_address
);
4419 trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
4420 wstep
->tp_number
, paddress (wstep
->tp_address
),
4421 target_pid_to_str (tinfo
->entry
.id
));
4424 *wstep_link
= wstep
->next
;
4425 release_while_stepping_state (wstep
);
4426 wstep
= *wstep_link
;
4430 /* We've just finished one step. */
4431 ++wstep
->current_step
;
4434 collect_data_at_step ((struct tracepoint_hit_ctx
*) &ctx
,
4435 stop_pc
, tpoint
, wstep
->current_step
);
4437 if (wstep
->current_step
>= tpoint
->step_count
)
4439 /* The requested numbers of steps have occurred. */
4440 trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
4441 target_pid_to_str (tinfo
->entry
.id
),
4442 wstep
->tp_number
, paddress (wstep
->tp_address
));
4444 /* Unlink the wstep. */
4445 *wstep_link
= wstep
->next
;
4446 release_while_stepping_state (wstep
);
4447 wstep
= *wstep_link
;
4449 /* Only check the hit count now, which ensure that we do all
4450 our stepping before stopping the run. */
4451 if (tpoint
->pass_count
> 0
4452 && tpoint
->hit_count
>= tpoint
->pass_count
4453 && stopping_tracepoint
== NULL
)
4454 stopping_tracepoint
= tpoint
;
4458 /* Keep single-stepping until the requested numbers of steps
4460 wstep_link
= &wstep
->next
;
4461 wstep
= *wstep_link
;
4464 if (stopping_tracepoint
4465 || trace_buffer_is_full
4466 || expr_eval_result
!= expr_eval_no_error
)
4476 /* Handle any internal tracing control breakpoint hits. That means,
4477 pull traceframes from the IPA to our buffer, and syncing both
4478 tracing agents when the IPA's tracing stops for some reason. */
4481 handle_tracepoint_bkpts (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4483 /* Pull in fast tracepoint trace frames from the inferior in-process
4484 agent's buffer into our buffer. */
4486 if (!agent_loaded_p ())
4489 upload_fast_traceframes ();
4491 /* Check if the in-process agent had decided we should stop
4493 if (stop_pc
== ipa_sym_addrs
.addr_stop_tracing
)
4495 int ipa_trace_buffer_is_full
;
4496 CORE_ADDR ipa_stopping_tracepoint
;
4497 int ipa_expr_eval_result
;
4498 CORE_ADDR ipa_error_tracepoint
;
4500 trace_debug ("lib stopped at stop_tracing");
4502 read_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
,
4503 &ipa_trace_buffer_is_full
);
4505 read_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
4506 &ipa_stopping_tracepoint
);
4507 write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
, 0);
4509 read_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
,
4510 &ipa_error_tracepoint
);
4511 write_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
, 0);
4513 read_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
,
4514 &ipa_expr_eval_result
);
4515 write_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
, 0);
4517 trace_debug ("lib: trace_buffer_is_full: %d, "
4518 "stopping_tracepoint: %s, "
4519 "ipa_expr_eval_result: %d, "
4520 "error_tracepoint: %s, ",
4521 ipa_trace_buffer_is_full
,
4522 paddress (ipa_stopping_tracepoint
),
4523 ipa_expr_eval_result
,
4524 paddress (ipa_error_tracepoint
));
4528 if (ipa_trace_buffer_is_full
)
4529 trace_debug ("lib stopped due to full buffer.");
4530 if (ipa_stopping_tracepoint
)
4531 trace_debug ("lib stopped due to tpoint");
4532 if (ipa_stopping_tracepoint
)
4533 trace_debug ("lib stopped due to error");
4536 if (ipa_stopping_tracepoint
!= 0)
4539 = fast_tracepoint_from_ipa_tpoint_address (ipa_stopping_tracepoint
);
4541 else if (ipa_expr_eval_result
!= expr_eval_no_error
)
4543 expr_eval_result
= ipa_expr_eval_result
;
4545 = fast_tracepoint_from_ipa_tpoint_address (ipa_error_tracepoint
);
4550 else if (stop_pc
== ipa_sym_addrs
.addr_flush_trace_buffer
)
4552 trace_debug ("lib stopped at flush_trace_buffer");
4559 /* Return true if TINFO just hit a tracepoint. Collect data if
4563 tracepoint_was_hit (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
4565 struct tracepoint
*tpoint
;
4567 struct trap_tracepoint_ctx ctx
;
4569 /* Not tracing, don't handle. */
4573 ctx
.base
.type
= trap_tracepoint
;
4574 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
4576 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
4578 /* Note that we collect fast tracepoints here as well. We'll
4579 step over the fast tracepoint jump later, which avoids the
4580 double collect. However, we don't collect for static
4581 tracepoints here, because UST markers are compiled in program,
4582 and probes will be executed in program. So static tracepoints
4583 are collected there. */
4584 if (tpoint
->enabled
&& stop_pc
== tpoint
->address
4585 && tpoint
->type
!= static_tracepoint
)
4587 trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
4588 target_pid_to_str (tinfo
->entry
.id
),
4589 tpoint
->number
, paddress (tpoint
->address
));
4591 /* Test the condition if present, and collect if true. */
4593 || (condition_true_at_tracepoint
4594 ((struct tracepoint_hit_ctx
*) &ctx
, tpoint
)))
4595 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
4598 if (stopping_tracepoint
4599 || trace_buffer_is_full
4600 || expr_eval_result
!= expr_eval_no_error
)
4604 /* If the tracepoint had a 'while-stepping' action, then set
4605 the thread to collect this tracepoint on the following
4607 else if (tpoint
->step_count
> 0)
4609 add_while_stepping_state (tinfo
,
4610 tpoint
->number
, tpoint
->address
);
4622 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4623 struct ust_marker_data
;
4624 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4625 struct traceframe
*tframe
);
4628 /* Create a trace frame for the hit of the given tracepoint in the
4632 collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
, CORE_ADDR stop_pc
,
4633 struct tracepoint
*tpoint
)
4635 struct traceframe
*tframe
;
4638 /* Only count it as a hit when we actually collect data. */
4639 tpoint
->hit_count
++;
4641 /* If we've exceeded a defined pass count, record the event for
4642 later, and finish the collection for this hit. This test is only
4643 for nonstepping tracepoints, stepping tracepoints test at the end
4644 of their while-stepping loop. */
4645 if (tpoint
->pass_count
> 0
4646 && tpoint
->hit_count
>= tpoint
->pass_count
4647 && tpoint
->step_count
== 0
4648 && stopping_tracepoint
== NULL
)
4649 stopping_tracepoint
= tpoint
;
4651 trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64
,
4652 tpoint
->number
, paddress (tpoint
->address
), tpoint
->hit_count
);
4654 tframe
= add_traceframe (tpoint
);
4658 for (acti
= 0; acti
< tpoint
->numactions
; ++acti
)
4660 #ifndef IN_PROCESS_AGENT
4661 trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
4662 tpoint
->number
, paddress (tpoint
->address
),
4663 tpoint
->actions_str
[acti
]);
4666 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4667 tpoint
->actions
[acti
]);
4670 finish_traceframe (tframe
);
4673 if (tframe
== NULL
&& tracing
)
4674 trace_buffer_is_full
= 1;
4677 #ifndef IN_PROCESS_AGENT
4680 collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
4682 struct tracepoint
*tpoint
, int current_step
)
4684 struct traceframe
*tframe
;
4687 trace_debug ("Making new step traceframe for "
4688 "tracepoint %d at 0x%s, step %d of %" PRIu64
", hit %" PRIu64
,
4689 tpoint
->number
, paddress (tpoint
->address
),
4690 current_step
, tpoint
->step_count
,
4693 tframe
= add_traceframe (tpoint
);
4697 for (acti
= 0; acti
< tpoint
->num_step_actions
; ++acti
)
4699 trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'",
4700 tpoint
->number
, paddress (tpoint
->address
),
4701 tpoint
->step_actions_str
[acti
]);
4703 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4704 tpoint
->step_actions
[acti
]);
4707 finish_traceframe (tframe
);
4710 if (tframe
== NULL
&& tracing
)
4711 trace_buffer_is_full
= 1;
4716 #ifdef IN_PROCESS_AGENT
4717 /* The target description used by the IPA. Given that the IPA library
4718 is built for a specific architecture that is loaded into the
4719 inferior, there only needs to be one such description per
4721 const struct target_desc
*ipa_tdesc
;
4724 static struct regcache
*
4725 get_context_regcache (struct tracepoint_hit_ctx
*ctx
)
4727 struct regcache
*regcache
= NULL
;
4729 #ifdef IN_PROCESS_AGENT
4730 if (ctx
->type
== fast_tracepoint
)
4732 struct fast_tracepoint_ctx
*fctx
= (struct fast_tracepoint_ctx
*) ctx
;
4733 if (!fctx
->regcache_initted
)
4735 fctx
->regcache_initted
= 1;
4736 init_register_cache (&fctx
->regcache
, ipa_tdesc
, fctx
->regspace
);
4737 supply_regblock (&fctx
->regcache
, NULL
);
4738 supply_fast_tracepoint_registers (&fctx
->regcache
, fctx
->regs
);
4740 regcache
= &fctx
->regcache
;
4743 if (ctx
->type
== static_tracepoint
)
4745 struct static_tracepoint_ctx
*sctx
4746 = (struct static_tracepoint_ctx
*) ctx
;
4748 if (!sctx
->regcache_initted
)
4750 sctx
->regcache_initted
= 1;
4751 init_register_cache (&sctx
->regcache
, ipa_tdesc
, sctx
->regspace
);
4752 supply_regblock (&sctx
->regcache
, NULL
);
4753 /* Pass down the tracepoint address, because REGS doesn't
4754 include the PC, but we know what it must have been. */
4755 supply_static_tracepoint_registers (&sctx
->regcache
,
4756 (const unsigned char *)
4758 sctx
->tpoint
->address
);
4760 regcache
= &sctx
->regcache
;
4764 if (ctx
->type
== trap_tracepoint
)
4766 struct trap_tracepoint_ctx
*tctx
= (struct trap_tracepoint_ctx
*) ctx
;
4767 regcache
= tctx
->regcache
;
4771 gdb_assert (regcache
!= NULL
);
4777 do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4779 struct tracepoint
*tpoint
,
4780 struct traceframe
*tframe
,
4781 struct tracepoint_action
*taction
)
4783 enum eval_result_type err
;
4785 switch (taction
->type
)
4789 struct collect_memory_action
*maction
;
4790 struct eval_agent_expr_context ax_ctx
;
4792 maction
= (struct collect_memory_action
*) taction
;
4793 ax_ctx
.regcache
= NULL
;
4794 ax_ctx
.tframe
= tframe
;
4795 ax_ctx
.tpoint
= tpoint
;
4797 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
4798 pulongest (maction
->len
),
4799 paddress (maction
->addr
), maction
->basereg
);
4800 /* (should use basereg) */
4801 agent_mem_read (&ax_ctx
, NULL
, (CORE_ADDR
) maction
->addr
,
4807 unsigned char *regspace
;
4808 struct regcache tregcache
;
4809 struct regcache
*context_regcache
;
4812 trace_debug ("Want to collect registers");
4814 context_regcache
= get_context_regcache (ctx
);
4815 regcache_size
= register_cache_size (context_regcache
->tdesc
);
4817 /* Collect all registers for now. */
4818 regspace
= add_traceframe_block (tframe
, tpoint
, 1 + regcache_size
);
4819 if (regspace
== NULL
)
4821 trace_debug ("Trace buffer block allocation failed, skipping");
4824 /* Identify a register block. */
4827 /* Wrap the regblock in a register cache (in the stack, we
4828 don't want to malloc here). */
4829 init_register_cache (&tregcache
, context_regcache
->tdesc
,
4832 /* Copy the register data to the regblock. */
4833 regcache_cpy (&tregcache
, context_regcache
);
4835 #ifndef IN_PROCESS_AGENT
4836 /* On some platforms, trap-based tracepoints will have the PC
4837 pointing to the next instruction after the trap, but we
4838 don't want the user or GDB trying to guess whether the
4839 saved PC needs adjusting; so always record the adjusted
4840 stop_pc. Note that we can't use tpoint->address instead,
4841 since it will be wrong for while-stepping actions. This
4842 adjustment is a nop for fast tracepoints collected from the
4843 in-process lib (but not if GDBserver is collecting one
4844 preemptively), since the PC had already been adjusted to
4845 contain the tracepoint's address by the jump pad. */
4846 trace_debug ("Storing stop pc (0x%s) in regblock",
4847 paddress (stop_pc
));
4849 /* This changes the regblock, not the thread's
4851 regcache_write_pc (&tregcache
, stop_pc
);
4857 struct eval_expr_action
*eaction
;
4858 struct eval_agent_expr_context ax_ctx
;
4860 eaction
= (struct eval_expr_action
*) taction
;
4861 ax_ctx
.regcache
= get_context_regcache (ctx
);
4862 ax_ctx
.tframe
= tframe
;
4863 ax_ctx
.tpoint
= tpoint
;
4865 trace_debug ("Want to evaluate expression");
4867 err
= gdb_eval_agent_expr (&ax_ctx
, eaction
->expr
, NULL
);
4869 if (err
!= expr_eval_no_error
)
4871 record_tracepoint_error (tpoint
, "action expression", err
);
4878 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4879 trace_debug ("Want to collect static trace data");
4880 collect_ust_data_at_tracepoint (ctx
, tframe
);
4882 trace_debug ("warning: collecting static trace data, "
4883 "but static tracepoints are not supported");
4888 trace_debug ("unknown trace action '%c', ignoring", taction
->type
);
4894 condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4895 struct tracepoint
*tpoint
)
4898 enum eval_result_type err
;
4900 /* Presently, gdbserver doesn't run compiled conditions, only the
4901 IPA does. If the program stops at a fast tracepoint's address
4902 (e.g., due to a breakpoint, trap tracepoint, or stepping),
4903 gdbserver preemptively collect the fast tracepoint. Later, on
4904 resume, gdbserver steps over the fast tracepoint like it steps
4905 over breakpoints, so that the IPA doesn't see that fast
4906 tracepoint. This avoids double collects of fast tracepoints in
4907 that stopping scenario. Having gdbserver itself handle the fast
4908 tracepoint gives the user a consistent view of when fast or trap
4909 tracepoints are collected, compared to an alternative where only
4910 trap tracepoints are collected on stop, and fast tracepoints on
4911 resume. When a fast tracepoint is being processed by gdbserver,
4912 it is always the non-compiled condition expression that is
4914 #ifdef IN_PROCESS_AGENT
4915 if (tpoint
->compiled_cond
)
4917 struct fast_tracepoint_ctx
*fctx
= (struct fast_tracepoint_ctx
*) ctx
;
4918 err
= ((condfn
) (uintptr_t) (tpoint
->compiled_cond
)) (fctx
->regs
, &value
);
4923 struct eval_agent_expr_context ax_ctx
;
4925 ax_ctx
.regcache
= get_context_regcache (ctx
);
4926 ax_ctx
.tframe
= NULL
;
4927 ax_ctx
.tpoint
= tpoint
;
4929 err
= gdb_eval_agent_expr (&ax_ctx
, tpoint
->cond
, &value
);
4931 if (err
!= expr_eval_no_error
)
4933 record_tracepoint_error (tpoint
, "condition", err
);
4934 /* The error case must return false. */
4938 trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
4939 tpoint
->number
, paddress (tpoint
->address
),
4941 return (value
? 1 : 0);
4944 /* Do memory copies for bytecodes. */
4945 /* Do the recording of memory blocks for actions and bytecodes. */
4948 agent_mem_read (struct eval_agent_expr_context
*ctx
,
4949 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4951 unsigned char *mspace
;
4952 ULONGEST remaining
= len
;
4953 unsigned short blocklen
;
4955 /* If a 'to' buffer is specified, use it. */
4958 read_inferior_memory (from
, to
, len
);
4962 /* Otherwise, create a new memory block in the trace buffer. */
4963 while (remaining
> 0)
4967 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4968 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
4969 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
4972 /* Identify block as a memory block. */
4975 /* Record address and size. */
4976 memcpy (mspace
, &from
, sizeof (from
));
4977 mspace
+= sizeof (from
);
4978 memcpy (mspace
, &blocklen
, sizeof (blocklen
));
4979 mspace
+= sizeof (blocklen
);
4980 /* Record the memory block proper. */
4981 read_inferior_memory (from
, mspace
, blocklen
);
4982 trace_debug ("%d bytes recorded", blocklen
);
4983 remaining
-= blocklen
;
4990 agent_mem_read_string (struct eval_agent_expr_context
*ctx
,
4991 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4993 unsigned char *buf
, *mspace
;
4994 ULONGEST remaining
= len
;
4995 unsigned short blocklen
, i
;
4997 /* To save a bit of space, block lengths are 16-bit, so break large
4998 requests into multiple blocks. Bordering on overkill for strings,
4999 but it could happen that someone specifies a large max length. */
5000 while (remaining
> 0)
5004 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
5005 /* We want working space to accumulate nonzero bytes, since
5006 traceframes must have a predecided size (otherwise it gets
5007 harder to wrap correctly for the circular case, etc). */
5008 buf
= (unsigned char *) xmalloc (blocklen
+ 1);
5009 for (i
= 0; i
< blocklen
; ++i
)
5011 /* Read the string one byte at a time, in case the string is
5012 at the end of a valid memory area - we don't want a
5013 correctly-terminated string to engender segvio
5015 read_inferior_memory (from
+ i
, buf
+ i
, 1);
5020 /* Make sure outer loop stops now too. */
5021 remaining
= blocklen
;
5025 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
5026 mspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
, sp
);
5032 /* Identify block as a memory block. */
5035 /* Record address and size. */
5036 memcpy ((void *) mspace
, (void *) &from
, sizeof (from
));
5037 mspace
+= sizeof (from
);
5038 memcpy ((void *) mspace
, (void *) &blocklen
, sizeof (blocklen
));
5039 mspace
+= sizeof (blocklen
);
5040 /* Copy the string contents. */
5041 memcpy ((void *) mspace
, (void *) buf
, blocklen
);
5042 remaining
-= blocklen
;
5049 /* Record the value of a trace state variable. */
5052 agent_tsv_read (struct eval_agent_expr_context
*ctx
, int n
)
5054 unsigned char *vspace
;
5057 vspace
= add_traceframe_block (ctx
->tframe
, ctx
->tpoint
,
5058 1 + sizeof (n
) + sizeof (LONGEST
));
5061 /* Identify block as a variable. */
5063 /* Record variable's number and value. */
5064 memcpy (vspace
+ 1, &n
, sizeof (n
));
5065 val
= get_trace_state_variable_value (n
);
5066 memcpy (vspace
+ 1 + sizeof (n
), &val
, sizeof (val
));
5067 trace_debug ("Variable %d recorded", n
);
5071 #ifndef IN_PROCESS_AGENT
5073 /* Callback for traceframe_walk_blocks, used to find a given block
5074 type in a traceframe. */
5077 match_blocktype (char blocktype
, unsigned char *dataptr
, void *data
)
5079 char *wantedp
= (char *) data
;
5081 if (*wantedp
== blocktype
)
5087 /* Walk over all traceframe blocks of the traceframe buffer starting
5088 at DATABASE, of DATASIZE bytes long, and call CALLBACK for each
5089 block found, passing in DATA unmodified. If CALLBACK returns true,
5090 this returns a pointer to where the block is found. Returns NULL
5091 if no callback call returned true, indicating that all blocks have
5094 static unsigned char *
5095 traceframe_walk_blocks (unsigned char *database
, unsigned int datasize
,
5097 int (*callback
) (char blocktype
,
5098 unsigned char *dataptr
,
5102 unsigned char *dataptr
;
5106 trace_debug ("traceframe %d has no data", tfnum
);
5110 /* Iterate through a traceframe's blocks, looking for a block of the
5112 for (dataptr
= database
;
5113 dataptr
< database
+ datasize
;
5117 unsigned short mlen
;
5119 if (dataptr
== trace_buffer_wrap
)
5121 /* Adjust to reflect wrapping part of the frame around to
5123 datasize
= dataptr
- database
;
5124 dataptr
= database
= trace_buffer_lo
;
5127 blocktype
= *dataptr
++;
5129 if ((*callback
) (blocktype
, dataptr
, data
))
5135 /* Skip over the registers block. */
5136 dataptr
+= current_target_desc ()->registers_size
;
5139 /* Skip over the memory block. */
5140 dataptr
+= sizeof (CORE_ADDR
);
5141 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5142 dataptr
+= (sizeof (mlen
) + mlen
);
5145 /* Skip over the TSV block. */
5146 dataptr
+= (sizeof (int) + sizeof (LONGEST
));
5149 /* Skip over the static trace data block. */
5150 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5151 dataptr
+= (sizeof (mlen
) + mlen
);
5154 trace_debug ("traceframe %d has unknown block type 0x%x",
5163 /* Look for the block of type TYPE_WANTED in the trameframe starting
5164 at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
5167 static unsigned char *
5168 traceframe_find_block_type (unsigned char *database
, unsigned int datasize
,
5169 int tfnum
, char type_wanted
)
5171 return traceframe_walk_blocks (database
, datasize
, tfnum
,
5172 match_blocktype
, &type_wanted
);
5175 static unsigned char *
5176 traceframe_find_regblock (struct traceframe
*tframe
, int tfnum
)
5178 unsigned char *regblock
;
5180 regblock
= traceframe_find_block_type (tframe
->data
,
5184 if (regblock
== NULL
)
5185 trace_debug ("traceframe %d has no register data", tfnum
);
5190 /* Get registers from a traceframe. */
5193 fetch_traceframe_registers (int tfnum
, struct regcache
*regcache
, int regnum
)
5195 unsigned char *dataptr
;
5196 struct tracepoint
*tpoint
;
5197 struct traceframe
*tframe
;
5199 tframe
= find_traceframe (tfnum
);
5203 trace_debug ("traceframe %d not found", tfnum
);
5207 dataptr
= traceframe_find_regblock (tframe
, tfnum
);
5208 if (dataptr
== NULL
)
5210 /* Mark registers unavailable. */
5211 supply_regblock (regcache
, NULL
);
5213 /* We can generally guess at a PC, although this will be
5214 misleading for while-stepping frames and multi-location
5216 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
5218 regcache_write_pc (regcache
, tpoint
->address
);
5221 supply_regblock (regcache
, dataptr
);
5227 traceframe_get_pc (struct traceframe
*tframe
)
5229 struct regcache regcache
;
5230 unsigned char *dataptr
;
5231 const struct target_desc
*tdesc
= current_target_desc ();
5233 dataptr
= traceframe_find_regblock (tframe
, -1);
5234 if (dataptr
== NULL
)
5237 init_register_cache (®cache
, tdesc
, dataptr
);
5238 return regcache_read_pc (®cache
);
5241 /* Read a requested block of memory from a trace frame. */
5244 traceframe_read_mem (int tfnum
, CORE_ADDR addr
,
5245 unsigned char *buf
, ULONGEST length
,
5248 struct traceframe
*tframe
;
5249 unsigned char *database
, *dataptr
;
5250 unsigned int datasize
;
5252 unsigned short mlen
;
5254 trace_debug ("traceframe_read_mem");
5256 tframe
= find_traceframe (tfnum
);
5260 trace_debug ("traceframe %d not found", tfnum
);
5264 datasize
= tframe
->data_size
;
5265 database
= dataptr
= &tframe
->data
[0];
5267 /* Iterate through a traceframe's blocks, looking for memory. */
5268 while ((dataptr
= traceframe_find_block_type (dataptr
,
5270 - (dataptr
- database
),
5271 tfnum
, 'M')) != NULL
)
5273 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5274 dataptr
+= sizeof (maddr
);
5275 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5276 dataptr
+= sizeof (mlen
);
5277 trace_debug ("traceframe %d has %d bytes at %s",
5278 tfnum
, mlen
, paddress (maddr
));
5280 /* If the block includes the first part of the desired range,
5281 return as much it has; GDB will re-request the remainder,
5282 which might be in a different block of this trace frame. */
5283 if (maddr
<= addr
&& addr
< (maddr
+ mlen
))
5285 ULONGEST amt
= (maddr
+ mlen
) - addr
;
5289 memcpy (buf
, dataptr
+ (addr
- maddr
), amt
);
5294 /* Skip over this block. */
5298 trace_debug ("traceframe %d has no memory data for the desired region",
5306 traceframe_read_tsv (int tsvnum
, LONGEST
*val
)
5309 struct traceframe
*tframe
;
5310 unsigned char *database
, *dataptr
;
5311 unsigned int datasize
;
5315 trace_debug ("traceframe_read_tsv");
5317 tfnum
= current_traceframe
;
5321 trace_debug ("no current traceframe");
5325 tframe
= find_traceframe (tfnum
);
5329 trace_debug ("traceframe %d not found", tfnum
);
5333 datasize
= tframe
->data_size
;
5334 database
= dataptr
= &tframe
->data
[0];
5336 /* Iterate through a traceframe's blocks, looking for the last
5338 while ((dataptr
= traceframe_find_block_type (dataptr
,
5340 - (dataptr
- database
),
5341 tfnum
, 'V')) != NULL
)
5343 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5344 dataptr
+= sizeof (vnum
);
5346 trace_debug ("traceframe %d has variable %d", tfnum
, vnum
);
5348 /* Check that this is the variable we want. */
5351 memcpy (val
, dataptr
, sizeof (*val
));
5355 /* Skip over this block. */
5356 dataptr
+= sizeof (LONGEST
);
5360 trace_debug ("traceframe %d has no data for variable %d",
5365 /* Read a requested block of static tracepoint data from a trace
5369 traceframe_read_sdata (int tfnum
, ULONGEST offset
,
5370 unsigned char *buf
, ULONGEST length
,
5373 struct traceframe
*tframe
;
5374 unsigned char *database
, *dataptr
;
5375 unsigned int datasize
;
5376 unsigned short mlen
;
5378 trace_debug ("traceframe_read_sdata");
5380 tframe
= find_traceframe (tfnum
);
5384 trace_debug ("traceframe %d not found", tfnum
);
5388 datasize
= tframe
->data_size
;
5389 database
= &tframe
->data
[0];
5391 /* Iterate through a traceframe's blocks, looking for static
5393 dataptr
= traceframe_find_block_type (database
, datasize
,
5395 if (dataptr
!= NULL
)
5397 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5398 dataptr
+= sizeof (mlen
);
5401 if (offset
+ length
> mlen
)
5402 length
= mlen
- offset
;
5404 memcpy (buf
, dataptr
, length
);
5412 trace_debug ("traceframe %d has no static trace data", tfnum
);
5418 /* Callback for traceframe_walk_blocks. Builds a traceframe-info
5419 object. DATA is pointer to a struct buffer holding the
5420 traceframe-info object being built. */
5423 build_traceframe_info_xml (char blocktype
, unsigned char *dataptr
, void *data
)
5425 struct buffer
*buffer
= (struct buffer
*) data
;
5431 unsigned short mlen
;
5434 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5435 dataptr
+= sizeof (maddr
);
5436 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5437 dataptr
+= sizeof (mlen
);
5438 buffer_xml_printf (buffer
,
5439 "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5440 paddress (maddr
), phex_nz (mlen
, sizeof (mlen
)));
5447 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5448 buffer_xml_printf (buffer
, "<tvar id=\"%d\"/>\n", vnum
);
5457 warning ("Unhandled trace block type (%d) '%c ' "
5458 "while building trace frame info.",
5459 blocktype
, blocktype
);
5466 /* Build a traceframe-info object for traceframe number TFNUM into
5470 traceframe_read_info (int tfnum
, struct buffer
*buffer
)
5472 struct traceframe
*tframe
;
5474 trace_debug ("traceframe_read_info");
5476 tframe
= find_traceframe (tfnum
);
5480 trace_debug ("traceframe %d not found", tfnum
);
5484 buffer_grow_str (buffer
, "<traceframe-info>\n");
5485 traceframe_walk_blocks (tframe
->data
, tframe
->data_size
,
5486 tfnum
, build_traceframe_info_xml
, buffer
);
5487 buffer_grow_str0 (buffer
, "</traceframe-info>\n");
5491 /* Return the first fast tracepoint whose jump pad contains PC. */
5493 static struct tracepoint
*
5494 fast_tracepoint_from_jump_pad_address (CORE_ADDR pc
)
5496 struct tracepoint
*tpoint
;
5498 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5499 if (tpoint
->type
== fast_tracepoint
)
5500 if (tpoint
->jump_pad
<= pc
&& pc
< tpoint
->jump_pad_end
)
5506 /* Return the first fast tracepoint whose trampoline contains PC. */
5508 static struct tracepoint
*
5509 fast_tracepoint_from_trampoline_address (CORE_ADDR pc
)
5511 struct tracepoint
*tpoint
;
5513 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5515 if (tpoint
->type
== fast_tracepoint
5516 && tpoint
->trampoline
<= pc
&& pc
< tpoint
->trampoline_end
)
5523 /* Return GDBserver's tracepoint that matches the IP Agent's
5524 tracepoint object that lives at IPA_TPOINT_OBJ in the IP Agent's
5527 static struct tracepoint
*
5528 fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR ipa_tpoint_obj
)
5530 struct tracepoint
*tpoint
;
5532 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5533 if (tpoint
->type
== fast_tracepoint
)
5534 if (tpoint
->obj_addr_on_target
== ipa_tpoint_obj
)
5542 /* The type of the object that is used to synchronize fast tracepoint
5545 typedef struct collecting_t
5547 /* The fast tracepoint number currently collecting. */
5550 /* A number that GDBserver can use to identify the thread that is
5551 presently holding the collect lock. This need not (and usually
5552 is not) the thread id, as getting the current thread ID usually
5553 requires a system call, which we want to avoid like the plague.
5554 Usually this is thread's TCB, found in the TLS (pseudo-)
5555 register, which is readable with a single insn on several
5557 uintptr_t thread_area
;
5560 #ifndef IN_PROCESS_AGENT
5563 force_unlock_trace_buffer (void)
5565 write_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
, 0);
5568 /* Check if the thread identified by THREAD_AREA which is stopped at
5569 STOP_PC, is presently locking the fast tracepoint collection, and
5570 if so, gather some status of said collection. Returns 0 if the
5571 thread isn't collecting or in the jump pad at all. 1, if in the
5572 jump pad (or within gdb_collect) and hasn't executed the adjusted
5573 original insn yet (can set a breakpoint there and run to it). 2,
5574 if presently executing the adjusted original insn --- in which
5575 case, if we want to move the thread out of the jump pad, we need to
5576 single-step it until this function returns 0. */
5579 fast_tracepoint_collecting (CORE_ADDR thread_area
,
5581 struct fast_tpoint_collect_status
*status
)
5583 CORE_ADDR ipa_collecting
;
5584 CORE_ADDR ipa_gdb_jump_pad_buffer
, ipa_gdb_jump_pad_buffer_end
;
5585 CORE_ADDR ipa_gdb_trampoline_buffer
;
5586 CORE_ADDR ipa_gdb_trampoline_buffer_end
;
5587 struct tracepoint
*tpoint
;
5588 int needs_breakpoint
;
5590 /* The thread THREAD_AREA is either:
5592 0. not collecting at all, not within the jump pad, or within
5593 gdb_collect or one of its callees.
5595 1. in the jump pad and haven't reached gdb_collect
5597 2. within gdb_collect (out of the jump pad) (collect is set)
5599 3. we're in the jump pad, after gdb_collect having returned,
5600 possibly executing the adjusted insns.
5602 For cases 1 and 3, `collecting' may or not be set. The jump pad
5603 doesn't have any complicated jump logic, so we can tell if the
5604 thread is executing the adjust original insn or not by just
5605 matching STOP_PC with known jump pad addresses. If we it isn't
5606 yet executing the original insn, set a breakpoint there, and let
5607 the thread run to it, so to quickly step over a possible (many
5608 insns) gdb_collect call. Otherwise, or when the breakpoint is
5609 hit, only a few (small number of) insns are left to be executed
5610 in the jump pad. Single-step the thread until it leaves the
5615 needs_breakpoint
= 0;
5616 trace_debug ("fast_tracepoint_collecting");
5618 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
5619 &ipa_gdb_jump_pad_buffer
))
5621 internal_error (__FILE__
, __LINE__
,
5622 "error extracting `gdb_jump_pad_buffer'");
5624 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer_end
,
5625 &ipa_gdb_jump_pad_buffer_end
))
5627 internal_error (__FILE__
, __LINE__
,
5628 "error extracting `gdb_jump_pad_buffer_end'");
5631 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer
,
5632 &ipa_gdb_trampoline_buffer
))
5634 internal_error (__FILE__
, __LINE__
,
5635 "error extracting `gdb_trampoline_buffer'");
5637 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_trampoline_buffer_end
,
5638 &ipa_gdb_trampoline_buffer_end
))
5640 internal_error (__FILE__
, __LINE__
,
5641 "error extracting `gdb_trampoline_buffer_end'");
5644 if (ipa_gdb_jump_pad_buffer
<= stop_pc
5645 && stop_pc
< ipa_gdb_jump_pad_buffer_end
)
5647 /* We can tell which tracepoint(s) the thread is collecting by
5648 matching the jump pad address back to the tracepoint. */
5649 tpoint
= fast_tracepoint_from_jump_pad_address (stop_pc
);
5652 warning ("in jump pad, but no matching tpoint?");
5657 trace_debug ("in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5659 tpoint
->number
, paddress (tpoint
->address
),
5660 paddress (tpoint
->jump_pad
),
5661 paddress (tpoint
->jump_pad_end
),
5662 paddress (tpoint
->adjusted_insn_addr
),
5663 paddress (tpoint
->adjusted_insn_addr_end
));
5666 /* Definitely in the jump pad. May or may not need
5667 fast-exit-jump-pad breakpoint. */
5668 if (tpoint
->jump_pad
<= stop_pc
5669 && stop_pc
< tpoint
->adjusted_insn_addr
)
5670 needs_breakpoint
= 1;
5672 else if (ipa_gdb_trampoline_buffer
<= stop_pc
5673 && stop_pc
< ipa_gdb_trampoline_buffer_end
)
5675 /* We can tell which tracepoint(s) the thread is collecting by
5676 matching the trampoline address back to the tracepoint. */
5677 tpoint
= fast_tracepoint_from_trampoline_address (stop_pc
);
5680 warning ("in trampoline, but no matching tpoint?");
5685 trace_debug ("in trampoline of tpoint (%d, %s); trampoline(%s, %s)",
5686 tpoint
->number
, paddress (tpoint
->address
),
5687 paddress (tpoint
->trampoline
),
5688 paddress (tpoint
->trampoline_end
));
5691 /* Have not reached jump pad yet, but treat the trampoline as a
5692 part of the jump pad that is before the adjusted original
5694 needs_breakpoint
= 1;
5698 collecting_t ipa_collecting_obj
;
5700 /* If `collecting' is set/locked, then the THREAD_AREA thread
5701 may or not be the one holding the lock. We have to read the
5702 lock to find out. */
5704 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
,
5707 trace_debug ("fast_tracepoint_collecting:"
5708 " failed reading 'collecting' in the inferior");
5712 if (!ipa_collecting
)
5714 trace_debug ("fast_tracepoint_collecting: not collecting"
5715 " (and nobody is).");
5719 /* Some thread is collecting. Check which. */
5720 if (read_inferior_memory (ipa_collecting
,
5721 (unsigned char *) &ipa_collecting_obj
,
5722 sizeof (ipa_collecting_obj
)) != 0)
5725 if (ipa_collecting_obj
.thread_area
!= thread_area
)
5727 trace_debug ("fast_tracepoint_collecting: not collecting "
5728 "(another thread is)");
5733 = fast_tracepoint_from_ipa_tpoint_address (ipa_collecting_obj
.tpoint
);
5736 warning ("fast_tracepoint_collecting: collecting, "
5737 "but tpoint %s not found?",
5738 paddress ((CORE_ADDR
) ipa_collecting_obj
.tpoint
));
5742 /* The thread is within `gdb_collect', skip over the rest of
5743 fast tracepoint collection quickly using a breakpoint. */
5744 needs_breakpoint
= 1;
5747 /* The caller wants a bit of status detail. */
5750 status
->tpoint_num
= tpoint
->number
;
5751 status
->tpoint_addr
= tpoint
->address
;
5752 status
->adjusted_insn_addr
= tpoint
->adjusted_insn_addr
;
5753 status
->adjusted_insn_addr_end
= tpoint
->adjusted_insn_addr_end
;
5756 if (needs_breakpoint
)
5758 /* Hasn't executed the original instruction yet. Set breakpoint
5759 there, and wait till it's hit, then single-step until exiting
5763 fast_tracepoint_collecting, returning continue-until-break at %s",
5764 paddress (tpoint
->adjusted_insn_addr
));
5766 return 1; /* continue */
5770 /* Just single-step until exiting the jump pad. */
5772 trace_debug ("fast_tracepoint_collecting, returning "
5773 "need-single-step (%s-%s)",
5774 paddress (tpoint
->adjusted_insn_addr
),
5775 paddress (tpoint
->adjusted_insn_addr_end
));
5777 return 2; /* single-step */
5783 #ifdef IN_PROCESS_AGENT
5785 /* The global fast tracepoint collect lock. Points to a collecting_t
5786 object built on the stack by the jump pad, if presently locked;
5787 NULL if it isn't locked. Note that this lock *must* be set while
5788 executing any *function other than the jump pad. See
5789 fast_tracepoint_collecting. */
5791 IP_AGENT_EXPORT_VAR collecting_t
*collecting
;
5794 /* This routine, called from the jump pad (in asm) is designed to be
5795 called from the jump pads of fast tracepoints, thus it is on the
5798 IP_AGENT_EXPORT_FUNC
void
5799 gdb_collect (struct tracepoint
*tpoint
, unsigned char *regs
)
5801 struct fast_tracepoint_ctx ctx
;
5803 /* Don't do anything until the trace run is completely set up. */
5807 ctx
.base
.type
= fast_tracepoint
;
5809 ctx
.regcache_initted
= 0;
5810 /* Wrap the regblock in a register cache (in the stack, we don't
5811 want to malloc here). */
5812 ctx
.regspace
= (unsigned char *) alloca (ipa_tdesc
->registers_size
);
5813 if (ctx
.regspace
== NULL
)
5815 trace_debug ("Trace buffer block allocation failed, skipping");
5819 for (ctx
.tpoint
= tpoint
;
5820 ctx
.tpoint
!= NULL
&& ctx
.tpoint
->address
== tpoint
->address
;
5821 ctx
.tpoint
= ctx
.tpoint
->next
)
5823 if (!ctx
.tpoint
->enabled
)
5826 /* Multiple tracepoints of different types, such as fast tracepoint and
5827 static tracepoint, can be set at the same address. */
5828 if (ctx
.tpoint
->type
!= tpoint
->type
)
5831 /* Test the condition if present, and collect if true. */
5832 if (ctx
.tpoint
->cond
== NULL
5833 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5836 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5837 ctx
.tpoint
->address
, ctx
.tpoint
);
5839 /* Note that this will cause original insns to be written back
5840 to where we jumped from, but that's OK because we're jumping
5841 back to the next whole instruction. This will go badly if
5842 instruction restoration is not atomic though. */
5843 if (stopping_tracepoint
5844 || trace_buffer_is_full
5845 || expr_eval_result
!= expr_eval_no_error
)
5853 /* If there was a condition and it evaluated to false, the only
5854 way we would stop tracing is if there was an error during
5855 condition expression evaluation. */
5856 if (expr_eval_result
!= expr_eval_no_error
)
5867 #ifndef IN_PROCESS_AGENT
5870 get_raw_reg_func_addr (void)
5872 return ipa_sym_addrs
.addr_get_raw_reg
;
5876 get_get_tsv_func_addr (void)
5878 return ipa_sym_addrs
.addr_get_trace_state_variable_value
;
5882 get_set_tsv_func_addr (void)
5884 return ipa_sym_addrs
.addr_set_trace_state_variable_value
;
5888 compile_tracepoint_condition (struct tracepoint
*tpoint
,
5889 CORE_ADDR
*jump_entry
)
5891 CORE_ADDR entry_point
= *jump_entry
;
5892 enum eval_result_type err
;
5894 trace_debug ("Starting condition compilation for tracepoint %d\n",
5897 /* Initialize the global pointer to the code being built. */
5898 current_insn_ptr
= *jump_entry
;
5902 err
= compile_bytecodes (tpoint
->cond
);
5904 if (err
== expr_eval_no_error
)
5908 /* Record the beginning of the compiled code. */
5909 tpoint
->compiled_cond
= entry_point
;
5911 trace_debug ("Condition compilation for tracepoint %d complete\n",
5916 /* Leave the unfinished code in situ, but don't point to it. */
5918 tpoint
->compiled_cond
= 0;
5920 trace_debug ("Condition compilation for tracepoint %d failed, "
5922 tpoint
->number
, err
);
5925 /* Update the code pointer passed in. Note that we do this even if
5926 the compile fails, so that we can look at the partial results
5927 instead of letting them be overwritten. */
5928 *jump_entry
= current_insn_ptr
;
5930 /* Leave a gap, to aid dump decipherment. */
5934 /* We'll need to adjust these when we consider bi-arch setups, and big
5938 write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
)
5940 return write_inferior_memory (where
,
5941 (unsigned char *) &ptr
, sizeof (void *));
5944 /* The base pointer of the IPA's heap. This is the only memory the
5945 IPA is allowed to use. The IPA should _not_ call the inferior's
5946 `malloc' during operation. That'd be slow, and, most importantly,
5947 it may not be safe. We may be collecting a tracepoint in a signal
5948 handler, for example. */
5949 static CORE_ADDR target_tp_heap
;
5951 /* Allocate at least SIZE bytes of memory from the IPA heap, aligned
5955 target_malloc (ULONGEST size
)
5959 if (target_tp_heap
== 0)
5961 /* We have the pointer *address*, need what it points to. */
5962 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_tp_heap_buffer
,
5965 internal_error (__FILE__
, __LINE__
,
5966 "couldn't get target heap head pointer");
5970 ptr
= target_tp_heap
;
5971 target_tp_heap
+= size
;
5973 /* Pad to 8-byte alignment. */
5974 target_tp_heap
= ((target_tp_heap
+ 7) & ~0x7);
5980 download_agent_expr (struct agent_expr
*expr
)
5982 CORE_ADDR expr_addr
;
5983 CORE_ADDR expr_bytes
;
5985 expr_addr
= target_malloc (sizeof (*expr
));
5986 write_inferior_memory (expr_addr
, (unsigned char *) expr
, sizeof (*expr
));
5988 expr_bytes
= target_malloc (expr
->length
);
5989 write_inferior_data_ptr (expr_addr
+ offsetof (struct agent_expr
, bytes
),
5991 write_inferior_memory (expr_bytes
, expr
->bytes
, expr
->length
);
5996 /* Align V up to N bits. */
5997 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
5999 /* Sync tracepoint with IPA, but leave maintenance of linked list to caller. */
6002 download_tracepoint_1 (struct tracepoint
*tpoint
)
6004 struct tracepoint target_tracepoint
;
6005 CORE_ADDR tpptr
= 0;
6007 gdb_assert (tpoint
->type
== fast_tracepoint
6008 || tpoint
->type
== static_tracepoint
);
6010 if (tpoint
->cond
!= NULL
&& target_emit_ops () != NULL
)
6012 CORE_ADDR jentry
, jump_entry
;
6014 jentry
= jump_entry
= get_jump_space_head ();
6016 if (tpoint
->cond
!= NULL
)
6018 /* Pad to 8-byte alignment. (needed?) */
6019 /* Actually this should be left for the target to
6021 jentry
= UALIGN (jentry
, 8);
6023 compile_tracepoint_condition (tpoint
, &jentry
);
6026 /* Pad to 8-byte alignment. */
6027 jentry
= UALIGN (jentry
, 8);
6028 claim_jump_space (jentry
- jump_entry
);
6031 target_tracepoint
= *tpoint
;
6033 tpptr
= target_malloc (sizeof (*tpoint
));
6034 tpoint
->obj_addr_on_target
= tpptr
;
6036 /* Write the whole object. We'll fix up its pointers in a bit.
6037 Assume no next for now. This is fixed up above on the next
6038 iteration, if there's any. */
6039 target_tracepoint
.next
= NULL
;
6040 /* Need to clear this here too, since we're downloading the
6041 tracepoints before clearing our own copy. */
6042 target_tracepoint
.hit_count
= 0;
6044 write_inferior_memory (tpptr
, (unsigned char *) &target_tracepoint
,
6045 sizeof (target_tracepoint
));
6048 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6050 download_agent_expr (tpoint
->cond
));
6052 if (tpoint
->numactions
)
6055 CORE_ADDR actions_array
;
6057 /* The pointers array. */
6059 = target_malloc (sizeof (*tpoint
->actions
) * tpoint
->numactions
);
6060 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6064 /* Now for each pointer, download the action. */
6065 for (i
= 0; i
< tpoint
->numactions
; i
++)
6067 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6068 CORE_ADDR ipa_action
= action
->ops
->download (action
);
6070 if (ipa_action
!= 0)
6071 write_inferior_data_ptr
6072 (actions_array
+ i
* sizeof (*tpoint
->actions
),
6078 #define IPA_PROTO_FAST_TRACE_FLAG 0
6079 #define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
6080 #define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
6081 #define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
6082 #define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
6084 /* Send a command to agent to download and install tracepoint TPOINT. */
6087 tracepoint_send_agent (struct tracepoint
*tpoint
)
6089 char buf
[IPA_CMD_BUF_SIZE
];
6094 strcpy (p
, "FastTrace:");
6097 COPY_FIELD_TO_BUF (p
, tpoint
, number
);
6098 COPY_FIELD_TO_BUF (p
, tpoint
, address
);
6099 COPY_FIELD_TO_BUF (p
, tpoint
, type
);
6100 COPY_FIELD_TO_BUF (p
, tpoint
, enabled
);
6101 COPY_FIELD_TO_BUF (p
, tpoint
, step_count
);
6102 COPY_FIELD_TO_BUF (p
, tpoint
, pass_count
);
6103 COPY_FIELD_TO_BUF (p
, tpoint
, numactions
);
6104 COPY_FIELD_TO_BUF (p
, tpoint
, hit_count
);
6105 COPY_FIELD_TO_BUF (p
, tpoint
, traceframe_usage
);
6106 COPY_FIELD_TO_BUF (p
, tpoint
, compiled_cond
);
6107 COPY_FIELD_TO_BUF (p
, tpoint
, orig_size
);
6110 p
= agent_expr_send (p
, tpoint
->cond
);
6112 /* tracepoint_action */
6113 for (i
= 0; i
< tpoint
->numactions
; i
++)
6115 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6117 p
[0] = action
->type
;
6118 p
= action
->ops
->send (&p
[1], action
);
6121 get_jump_space_head ();
6122 /* Copy the value of GDB_JUMP_PAD_HEAD to command buffer, so that
6123 agent can use jump pad from it. */
6124 if (tpoint
->type
== fast_tracepoint
)
6126 memcpy (p
, &gdb_jump_pad_head
, 8);
6130 ret
= run_inferior_command (buf
, (int) (ptrdiff_t) (p
- buf
));
6134 if (!startswith (buf
, "OK"))
6137 /* The value of tracepoint's target address is stored in BUF. */
6138 memcpy (&tpoint
->obj_addr_on_target
,
6139 &buf
[IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET
], 8);
6141 if (tpoint
->type
== fast_tracepoint
)
6144 = (unsigned char *) &buf
[IPA_PROTO_FAST_TRACE_FJUMP_INSN
];
6147 trace_debug ("agent: read from cmd_buf 0x%x 0x%x\n",
6148 (unsigned int) tpoint
->obj_addr_on_target
,
6149 (unsigned int) gdb_jump_pad_head
);
6151 memcpy (&gdb_jump_pad_head
, &buf
[IPA_PROTO_FAST_TRACE_JUMP_PAD
], 8);
6153 /* This has been done in agent. We should also set up record for it. */
6154 memcpy (&fjump_size
, &buf
[IPA_PROTO_FAST_TRACE_FJUMP_SIZE
], 4);
6157 = set_fast_tracepoint_jump (tpoint
->address
, insn
, fjump_size
);
6164 download_tracepoint (struct tracepoint
*tpoint
)
6166 struct tracepoint
*tp
, *tp_prev
;
6168 if (tpoint
->type
!= fast_tracepoint
6169 && tpoint
->type
!= static_tracepoint
)
6172 download_tracepoint_1 (tpoint
);
6174 /* Find the previous entry of TPOINT, which is fast tracepoint or
6175 static tracepoint. */
6177 for (tp
= tracepoints
; tp
!= tpoint
; tp
= tp
->next
)
6179 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
6185 CORE_ADDR tp_prev_target_next_addr
;
6187 /* Insert TPOINT after TP_PREV in IPA. */
6188 if (read_inferior_data_pointer (tp_prev
->obj_addr_on_target
6189 + offsetof (struct tracepoint
, next
),
6190 &tp_prev_target_next_addr
))
6192 internal_error (__FILE__
, __LINE__
,
6193 "error reading `tp_prev->next'");
6196 /* tpoint->next = tp_prev->next */
6197 write_inferior_data_ptr (tpoint
->obj_addr_on_target
6198 + offsetof (struct tracepoint
, next
),
6199 tp_prev_target_next_addr
);
6200 /* tp_prev->next = tpoint */
6201 write_inferior_data_ptr (tp_prev
->obj_addr_on_target
6202 + offsetof (struct tracepoint
, next
),
6203 tpoint
->obj_addr_on_target
);
6206 /* First object in list, set the head pointer in the
6208 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
,
6209 tpoint
->obj_addr_on_target
);
6214 download_trace_state_variables (void)
6216 CORE_ADDR ptr
= 0, prev_ptr
= 0;
6217 struct trace_state_variable
*tsv
;
6219 /* Start out empty. */
6220 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
, 0);
6222 for (tsv
= trace_state_variables
; tsv
!= NULL
; tsv
= tsv
->next
)
6224 struct trace_state_variable target_tsv
;
6226 /* TSV's with a getter have been initialized equally in both the
6227 inferior and GDBserver. Skip them. */
6228 if (tsv
->getter
!= NULL
)
6234 ptr
= target_malloc (sizeof (*tsv
));
6236 if (tsv
== trace_state_variables
)
6238 /* First object in list, set the head pointer in the
6241 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
,
6246 write_inferior_data_ptr (prev_ptr
6247 + offsetof (struct trace_state_variable
,
6252 /* Write the whole object. We'll fix up its pointers in a bit.
6253 Assume no next, fixup when needed. */
6254 target_tsv
.next
= NULL
;
6256 write_inferior_memory (ptr
, (unsigned char *) &target_tsv
,
6257 sizeof (target_tsv
));
6259 if (tsv
->name
!= NULL
)
6261 size_t size
= strlen (tsv
->name
) + 1;
6262 CORE_ADDR name_addr
= target_malloc (size
);
6263 write_inferior_memory (name_addr
,
6264 (unsigned char *) tsv
->name
, size
);
6265 write_inferior_data_ptr (ptr
6266 + offsetof (struct trace_state_variable
,
6271 gdb_assert (tsv
->getter
== NULL
);
6276 /* Fixup the next pointer in the last item in the list. */
6277 write_inferior_data_ptr (prev_ptr
6278 + offsetof (struct trace_state_variable
,
6283 /* Upload complete trace frames out of the IP Agent's trace buffer
6284 into GDBserver's trace buffer. This always uploads either all or
6285 no trace frames. This is the counter part of
6286 `trace_alloc_trace_buffer'. See its description of the atomic
6287 synching mechanism. */
6290 upload_fast_traceframes (void)
6292 unsigned int ipa_traceframe_read_count
, ipa_traceframe_write_count
;
6293 unsigned int ipa_traceframe_read_count_racy
, ipa_traceframe_write_count_racy
;
6295 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
6296 unsigned int curr_tbctrl_idx
;
6297 unsigned int ipa_trace_buffer_ctrl_curr
;
6298 unsigned int ipa_trace_buffer_ctrl_curr_old
;
6299 CORE_ADDR ipa_trace_buffer_ctrl_addr
;
6300 struct breakpoint
*about_to_request_buffer_space_bkpt
;
6301 CORE_ADDR ipa_trace_buffer_lo
;
6302 CORE_ADDR ipa_trace_buffer_hi
;
6304 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6305 &ipa_traceframe_read_count_racy
))
6307 /* This will happen in most targets if the current thread is
6312 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6313 &ipa_traceframe_write_count_racy
))
6316 trace_debug ("ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6317 ipa_traceframe_write_count_racy
6318 - ipa_traceframe_read_count_racy
,
6319 ipa_traceframe_write_count_racy
,
6320 ipa_traceframe_read_count_racy
);
6322 if (ipa_traceframe_write_count_racy
== ipa_traceframe_read_count_racy
)
6325 about_to_request_buffer_space_bkpt
6326 = set_breakpoint_at (ipa_sym_addrs
.addr_about_to_request_buffer_space
,
6329 if (read_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6330 &ipa_trace_buffer_ctrl_curr
))
6333 ipa_trace_buffer_ctrl_curr_old
= ipa_trace_buffer_ctrl_curr
;
6335 curr_tbctrl_idx
= ipa_trace_buffer_ctrl_curr
& ~GDBSERVER_FLUSH_COUNT_MASK
;
6338 unsigned int prev
, counter
;
6340 /* Update the token, with new counters, and the GDBserver stamp
6341 bit. Alway reuse the current TBC index. */
6342 prev
= ipa_trace_buffer_ctrl_curr
& GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6343 counter
= (prev
+ 0x100) & GDBSERVER_FLUSH_COUNT_MASK_CURR
;
6345 ipa_trace_buffer_ctrl_curr
= (GDBSERVER_UPDATED_FLUSH_COUNT_BIT
6351 if (write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6352 ipa_trace_buffer_ctrl_curr
))
6355 trace_debug ("Lib: Committed %08x -> %08x",
6356 ipa_trace_buffer_ctrl_curr_old
,
6357 ipa_trace_buffer_ctrl_curr
);
6359 /* Re-read these, now that we've installed the
6360 `about_to_request_buffer_space' breakpoint/lock. A thread could
6361 have finished a traceframe between the last read of these
6362 counters and setting the breakpoint above. If we start
6363 uploading, we never want to leave this function with
6364 traceframe_read_count != 0, otherwise, GDBserver could end up
6365 incrementing the counter tokens more than once (due to event loop
6366 nesting), which would break the IP agent's "effective" detection
6367 (see trace_alloc_trace_buffer). */
6368 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6369 &ipa_traceframe_read_count
))
6371 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6372 &ipa_traceframe_write_count
))
6377 trace_debug ("ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6378 ipa_traceframe_write_count
- ipa_traceframe_read_count
,
6379 ipa_traceframe_write_count
, ipa_traceframe_read_count
);
6381 if (ipa_traceframe_write_count
!= ipa_traceframe_write_count_racy
6382 || ipa_traceframe_read_count
!= ipa_traceframe_read_count_racy
)
6383 trace_debug ("note that ipa_traceframe_count's parts changed");
6386 /* Get the address of the current TBC object (the IP agent has an
6387 array of 3 such objects). The index is stored in the TBC
6389 ipa_trace_buffer_ctrl_addr
= ipa_sym_addrs
.addr_trace_buffer_ctrl
;
6390 ipa_trace_buffer_ctrl_addr
6391 += sizeof (struct ipa_trace_buffer_control
) * curr_tbctrl_idx
;
6393 if (read_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6394 (unsigned char *) &ipa_trace_buffer_ctrl
,
6395 sizeof (struct ipa_trace_buffer_control
)))
6398 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
6399 &ipa_trace_buffer_lo
))
6401 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
6402 &ipa_trace_buffer_hi
))
6405 /* Offsets are easier to grok for debugging than raw addresses,
6406 especially for the small trace buffer sizes that are useful for
6408 trace_debug ("Lib: Trace buffer [%d] start=%d free=%d "
6409 "endfree=%d wrap=%d hi=%d",
6411 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6412 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6413 (int) (ipa_trace_buffer_ctrl
.end_free
- ipa_trace_buffer_lo
),
6414 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6415 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6417 /* Note that the IPA's buffer is always circular. */
6419 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6421 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6422 ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6424 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6425 (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6426 - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6427 ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6430 tf
= IPA_FIRST_TRACEFRAME ();
6432 while (ipa_traceframe_write_count
- ipa_traceframe_read_count
)
6434 struct tracepoint
*tpoint
;
6435 struct traceframe
*tframe
;
6436 unsigned char *block
;
6437 struct traceframe ipa_tframe
;
6439 if (read_inferior_memory (tf
, (unsigned char *) &ipa_tframe
,
6440 offsetof (struct traceframe
, data
)))
6441 error ("Uploading: couldn't read traceframe at %s\n", paddress (tf
));
6443 if (ipa_tframe
.tpnum
== 0)
6445 internal_error (__FILE__
, __LINE__
,
6446 "Uploading: No (more) fast traceframes, but"
6447 " ipa_traceframe_count == %u??\n",
6448 ipa_traceframe_write_count
6449 - ipa_traceframe_read_count
);
6452 /* Note that this will be incorrect for multi-location
6454 tpoint
= find_next_tracepoint_by_number (NULL
, ipa_tframe
.tpnum
);
6456 tframe
= add_traceframe (tpoint
);
6459 trace_buffer_is_full
= 1;
6460 trace_debug ("Uploading: trace buffer is full");
6464 /* Copy the whole set of blocks in one go for now. FIXME:
6465 split this in smaller blocks. */
6466 block
= add_traceframe_block (tframe
, tpoint
,
6467 ipa_tframe
.data_size
);
6470 if (read_inferior_memory (tf
6471 + offsetof (struct traceframe
, data
),
6472 block
, ipa_tframe
.data_size
))
6473 error ("Uploading: Couldn't read traceframe data at %s\n",
6474 paddress (tf
+ offsetof (struct traceframe
, data
)));
6477 trace_debug ("Uploading: traceframe didn't fit");
6478 finish_traceframe (tframe
);
6481 tf
= IPA_NEXT_TRACEFRAME (tf
, &ipa_tframe
);
6483 /* If we freed the traceframe that wrapped around, go back
6484 to the non-wrap case. */
6485 if (tf
< ipa_trace_buffer_ctrl
.start
)
6487 trace_debug ("Lib: Discarding past the wraparound");
6488 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6490 ipa_trace_buffer_ctrl
.start
= tf
;
6491 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_ctrl
.start
;
6492 ++ipa_traceframe_read_count
;
6494 if (ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.free
6495 && ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.end_free
)
6497 trace_debug ("Lib: buffer is fully empty. "
6498 "Trace buffer [%d] start=%d free=%d endfree=%d",
6500 (int) (ipa_trace_buffer_ctrl
.start
6501 - ipa_trace_buffer_lo
),
6502 (int) (ipa_trace_buffer_ctrl
.free
6503 - ipa_trace_buffer_lo
),
6504 (int) (ipa_trace_buffer_ctrl
.end_free
6505 - ipa_trace_buffer_lo
));
6507 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
6508 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
6509 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
6510 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6513 trace_debug ("Uploaded a traceframe\n"
6514 "Lib: Trace buffer [%d] start=%d free=%d "
6515 "endfree=%d wrap=%d hi=%d",
6517 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6518 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6519 (int) (ipa_trace_buffer_ctrl
.end_free
6520 - ipa_trace_buffer_lo
),
6521 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6522 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6525 if (write_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6526 (unsigned char *) &ipa_trace_buffer_ctrl
,
6527 sizeof (struct ipa_trace_buffer_control
)))
6530 write_inferior_integer (ipa_sym_addrs
.addr_traceframe_read_count
,
6531 ipa_traceframe_read_count
);
6533 trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx
);
6537 delete_breakpoint (about_to_request_buffer_space_bkpt
);
6538 about_to_request_buffer_space_bkpt
= NULL
;
6542 if (trace_buffer_is_full
)
6547 #ifdef IN_PROCESS_AGENT
6549 IP_AGENT_EXPORT_VAR
int ust_loaded
;
6550 IP_AGENT_EXPORT_VAR
char cmd_buf
[IPA_CMD_BUF_SIZE
];
6554 /* Static tracepoints. */
6556 /* UST puts a "struct tracepoint" in the global namespace, which
6557 conflicts with our tracepoint. Arguably, being a library, it
6558 shouldn't take ownership of such a generic name. We work around it
6560 #define tracepoint ust_tracepoint
6561 #include <ust/ust.h>
6564 extern int serialize_to_text (char *outbuf
, int bufsize
,
6565 const char *fmt
, va_list ap
);
6567 #define GDB_PROBE_NAME "gdb"
6569 /* We dynamically search for the UST symbols instead of linking them
6570 in. This lets the user decide if the application uses static
6571 tracepoints, instead of always pulling libust.so in. This vector
6572 holds pointers to all functions we care about. */
6576 int (*serialize_to_text
) (char *outbuf
, int bufsize
,
6577 const char *fmt
, va_list ap
);
6579 int (*ltt_probe_register
) (struct ltt_available_probe
*pdata
);
6580 int (*ltt_probe_unregister
) (struct ltt_available_probe
*pdata
);
6582 int (*ltt_marker_connect
) (const char *channel
, const char *mname
,
6584 int (*ltt_marker_disconnect
) (const char *channel
, const char *mname
,
6587 void (*marker_iter_start
) (struct marker_iter
*iter
);
6588 void (*marker_iter_next
) (struct marker_iter
*iter
);
6589 void (*marker_iter_stop
) (struct marker_iter
*iter
);
6590 void (*marker_iter_reset
) (struct marker_iter
*iter
);
6595 /* Cast through typeof to catch incompatible API changes. Since UST
6596 only builds with gcc, we can freely use gcc extensions here
6598 #define GET_UST_SYM(SYM) \
6601 if (ust_ops.SYM == NULL) \
6602 ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6603 if (ust_ops.SYM == NULL) \
6607 #define USTF(SYM) ust_ops.SYM
6609 /* Get pointers to all libust.so functions we care about. */
6614 GET_UST_SYM (serialize_to_text
);
6616 GET_UST_SYM (ltt_probe_register
);
6617 GET_UST_SYM (ltt_probe_unregister
);
6618 GET_UST_SYM (ltt_marker_connect
);
6619 GET_UST_SYM (ltt_marker_disconnect
);
6621 GET_UST_SYM (marker_iter_start
);
6622 GET_UST_SYM (marker_iter_next
);
6623 GET_UST_SYM (marker_iter_stop
);
6624 GET_UST_SYM (marker_iter_reset
);
6630 /* Given an UST marker, return the matching gdb static tracepoint.
6631 The match is done by address. */
6633 static struct tracepoint
*
6634 ust_marker_to_static_tracepoint (const struct marker
*mdata
)
6636 struct tracepoint
*tpoint
;
6638 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
6640 if (tpoint
->type
!= static_tracepoint
)
6643 if (tpoint
->address
== (uintptr_t) mdata
->location
)
6650 /* The probe function we install on lttng/ust markers. Whenever a
6651 probed ust marker is hit, this function is called. This is similar
6652 to gdb_collect, only for static tracepoints, instead of fast
6656 gdb_probe (const struct marker
*mdata
, void *probe_private
,
6657 struct registers
*regs
, void *call_private
,
6658 const char *fmt
, va_list *args
)
6660 struct tracepoint
*tpoint
;
6661 struct static_tracepoint_ctx ctx
;
6663 /* Don't do anything until the trace run is completely set up. */
6666 trace_debug ("gdb_probe: not tracing\n");
6670 ctx
.base
.type
= static_tracepoint
;
6671 ctx
.regcache_initted
= 0;
6676 /* Wrap the regblock in a register cache (in the stack, we don't
6677 want to malloc here). */
6678 ctx
.regspace
= alloca (ipa_tdesc
->registers_size
);
6679 if (ctx
.regspace
== NULL
)
6681 trace_debug ("Trace buffer block allocation failed, skipping");
6685 tpoint
= ust_marker_to_static_tracepoint (mdata
);
6688 trace_debug ("gdb_probe: marker not known: "
6689 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6690 mdata
->location
, mdata
->channel
,
6691 mdata
->name
, mdata
->format
);
6695 if (!tpoint
->enabled
)
6697 trace_debug ("gdb_probe: tracepoint disabled");
6701 ctx
.tpoint
= tpoint
;
6703 trace_debug ("gdb_probe: collecting marker: "
6704 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6705 mdata
->location
, mdata
->channel
,
6706 mdata
->name
, mdata
->format
);
6708 /* Test the condition if present, and collect if true. */
6709 if (tpoint
->cond
== NULL
6710 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6713 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6714 tpoint
->address
, tpoint
);
6716 if (stopping_tracepoint
6717 || trace_buffer_is_full
6718 || expr_eval_result
!= expr_eval_no_error
)
6723 /* If there was a condition and it evaluated to false, the only
6724 way we would stop tracing is if there was an error during
6725 condition expression evaluation. */
6726 if (expr_eval_result
!= expr_eval_no_error
)
6731 /* Called if the gdb static tracepoint requested collecting "$_sdata",
6732 static tracepoint string data. This is a string passed to the
6733 tracing library by the user, at the time of the tracepoint marker
6734 call. E.g., in the UST marker call:
6736 trace_mark (ust, bar33, "str %s", "FOOBAZ");
6738 the collected data is "str FOOBAZ".
6742 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
6743 struct traceframe
*tframe
)
6745 struct static_tracepoint_ctx
*umd
= (struct static_tracepoint_ctx
*) ctx
;
6746 unsigned char *bufspace
;
6749 unsigned short blocklen
;
6753 trace_debug ("Wanted to collect static trace data, "
6754 "but there's no static trace data");
6758 va_copy (copy
, *umd
->args
);
6759 size
= USTF(serialize_to_text
) (NULL
, 0, umd
->fmt
, copy
);
6762 trace_debug ("Want to collect ust data");
6764 /* 'S' + size + string */
6765 bufspace
= add_traceframe_block (tframe
, umd
->tpoint
,
6766 1 + sizeof (blocklen
) + size
+ 1);
6767 if (bufspace
== NULL
)
6769 trace_debug ("Trace buffer block allocation failed, skipping");
6773 /* Identify a static trace data block. */
6776 blocklen
= size
+ 1;
6777 memcpy (bufspace
+ 1, &blocklen
, sizeof (blocklen
));
6779 va_copy (copy
, *umd
->args
);
6780 USTF(serialize_to_text
) ((char *) bufspace
+ 1 + sizeof (blocklen
),
6781 size
+ 1, umd
->fmt
, copy
);
6784 trace_debug ("Storing static tracepoint data in regblock: %s",
6785 bufspace
+ 1 + sizeof (blocklen
));
6788 /* The probe to register with lttng/ust. */
6789 static struct ltt_available_probe gdb_ust_probe
=
6796 #endif /* HAVE_UST */
6797 #endif /* IN_PROCESS_AGENT */
6799 #ifndef IN_PROCESS_AGENT
6801 /* Ask the in-process agent to run a command. Since we don't want to
6802 have to handle the IPA hitting breakpoints while running the
6803 command, we pause all threads, remove all breakpoints, and then set
6804 the helper thread re-running. We communicate with the helper
6805 thread by means of direct memory xfering, and a socket for
6809 run_inferior_command (char *cmd
, int len
)
6812 int pid
= ptid_get_pid (current_ptid
);
6814 trace_debug ("run_inferior_command: running: %s", cmd
);
6817 uninsert_all_breakpoints ();
6819 err
= agent_run_command (pid
, (const char *) cmd
, len
);
6821 reinsert_all_breakpoints ();
6827 #else /* !IN_PROCESS_AGENT */
6829 #include <sys/socket.h>
6832 #ifndef UNIX_PATH_MAX
6833 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6836 /* Where we put the socked used for synchronization. */
6837 #define SOCK_DIR P_tmpdir
6839 /* Thread ID of the helper thread. GDBserver reads this to know which
6840 is the help thread. This is an LWP id on Linux. */
6842 IP_AGENT_EXPORT_VAR
int helper_thread_id
;
6846 init_named_socket (const char *name
)
6849 struct sockaddr_un addr
;
6851 result
= fd
= socket (PF_UNIX
, SOCK_STREAM
, 0);
6854 warning ("socket creation failed: %s", strerror (errno
));
6858 addr
.sun_family
= AF_UNIX
;
6860 strncpy (addr
.sun_path
, name
, UNIX_PATH_MAX
);
6861 addr
.sun_path
[UNIX_PATH_MAX
- 1] = '\0';
6863 result
= access (name
, F_OK
);
6867 result
= unlink (name
);
6870 warning ("unlink failed: %s", strerror (errno
));
6874 warning ("socket %s already exists; overwriting", name
);
6877 result
= bind (fd
, (struct sockaddr
*) &addr
, sizeof (addr
));
6880 warning ("bind failed: %s", strerror (errno
));
6885 result
= listen (fd
, 1);
6888 warning ("listen: %s", strerror (errno
));
6896 static char agent_socket_name
[UNIX_PATH_MAX
];
6899 gdb_agent_socket_init (void)
6903 result
= xsnprintf (agent_socket_name
, UNIX_PATH_MAX
, "%s/gdb_ust%d",
6904 SOCK_DIR
, getpid ());
6905 if (result
>= UNIX_PATH_MAX
)
6907 trace_debug ("string overflow allocating socket name");
6911 fd
= init_named_socket (agent_socket_name
);
6913 warning ("Error initializing named socket (%s) for communication with the "
6914 "ust helper thread. Check that directory exists and that it "
6915 "is writable.", agent_socket_name
);
6922 /* The next marker to be returned on a qTsSTM command. */
6923 static const struct marker
*next_st
;
6925 /* Returns the first known marker. */
6930 struct marker_iter iter
;
6932 USTF(marker_iter_reset
) (&iter
);
6933 USTF(marker_iter_start
) (&iter
);
6938 /* Returns the marker following M. */
6940 const struct marker
*
6941 next_marker (const struct marker
*m
)
6943 struct marker_iter iter
;
6945 USTF(marker_iter_reset
) (&iter
);
6946 USTF(marker_iter_start
) (&iter
);
6948 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
6950 if (iter
.marker
== m
)
6952 USTF(marker_iter_next
) (&iter
);
6960 /* Return an hexstr version of the STR C string, fit for sending to
6964 cstr_to_hexstr (const char *str
)
6966 int len
= strlen (str
);
6967 char *hexstr
= xmalloc (len
* 2 + 1);
6968 bin2hex ((gdb_byte
*) str
, hexstr
, len
);
6972 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
6976 response_ust_marker (char *packet
, const struct marker
*st
)
6978 char *strid
, *format
, *tmp
;
6980 next_st
= next_marker (st
);
6982 tmp
= xmalloc (strlen (st
->channel
) + 1 +
6983 strlen (st
->name
) + 1);
6984 sprintf (tmp
, "%s/%s", st
->channel
, st
->name
);
6986 strid
= cstr_to_hexstr (tmp
);
6989 format
= cstr_to_hexstr (st
->format
);
6991 sprintf (packet
, "m%s:%s:%s",
6992 paddress ((uintptr_t) st
->location
),
7000 /* Return the first static tracepoint, and initialize the state
7001 machine that will iterate through all the static tracepoints. */
7004 cmd_qtfstm (char *packet
)
7006 trace_debug ("Returning first trace state variable definition");
7008 if (first_marker ())
7009 response_ust_marker (packet
, first_marker ());
7011 strcpy (packet
, "l");
7014 /* Return additional trace state variable definitions. */
7017 cmd_qtsstm (char *packet
)
7019 trace_debug ("Returning static tracepoint");
7022 response_ust_marker (packet
, next_st
);
7024 strcpy (packet
, "l");
7027 /* Disconnect the GDB probe from a marker at a given address. */
7030 unprobe_marker_at (char *packet
)
7034 struct marker_iter iter
;
7036 p
+= sizeof ("unprobe_marker_at:") - 1;
7038 p
= unpack_varlen_hex (p
, &address
);
7040 USTF(marker_iter_reset
) (&iter
);
7041 USTF(marker_iter_start
) (&iter
);
7042 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
7043 if ((uintptr_t ) iter
.marker
->location
== address
)
7047 result
= USTF(ltt_marker_disconnect
) (iter
.marker
->channel
,
7051 warning ("could not disable marker %s/%s",
7052 iter
.marker
->channel
, iter
.marker
->name
);
7057 /* Connect the GDB probe to a marker at a given address. */
7060 probe_marker_at (char *packet
)
7064 struct marker_iter iter
;
7067 p
+= sizeof ("probe_marker_at:") - 1;
7069 p
= unpack_varlen_hex (p
, &address
);
7071 USTF(marker_iter_reset
) (&iter
);
7073 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7075 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7076 if ((uintptr_t ) m
->location
== address
)
7080 trace_debug ("found marker for address. "
7081 "ltt_marker_connect (marker = %s/%s)",
7082 m
->channel
, m
->name
);
7084 result
= USTF(ltt_marker_connect
) (m
->channel
, m
->name
,
7086 if (result
&& result
!= -EEXIST
)
7087 trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
7088 m
->channel
, m
->name
, -result
);
7092 sprintf (packet
, "E.could not connect marker: channel=%s, name=%s",
7093 m
->channel
, m
->name
);
7097 strcpy (packet
, "OK");
7101 sprintf (packet
, "E.no marker found at 0x%s", paddress (address
));
7106 cmd_qtstmat (char *packet
)
7110 struct marker_iter iter
;
7113 p
+= sizeof ("qTSTMat:") - 1;
7115 p
= unpack_varlen_hex (p
, &address
);
7117 USTF(marker_iter_reset
) (&iter
);
7119 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7121 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7122 if ((uintptr_t ) m
->location
== address
)
7124 response_ust_marker (packet
, m
);
7128 strcpy (packet
, "l");
7138 USTF(ltt_probe_register
) (&gdb_ust_probe
);
7141 #endif /* HAVE_UST */
7143 #include <sys/syscall.h>
7146 gdb_agent_remove_socket (void)
7148 unlink (agent_socket_name
);
7151 /* Helper thread of agent. */
7154 gdb_agent_helper_thread (void *arg
)
7158 atexit (gdb_agent_remove_socket
);
7162 listen_fd
= gdb_agent_socket_init ();
7164 if (helper_thread_id
== 0)
7165 helper_thread_id
= syscall (SYS_gettid
);
7167 if (listen_fd
== -1)
7169 warning ("could not create sync socket\n");
7176 struct sockaddr_un sockaddr
;
7182 tmp
= sizeof (sockaddr
);
7186 fd
= accept (listen_fd
, (struct sockaddr
*) &sockaddr
, &tmp
);
7188 /* It seems an ERESTARTSYS can escape out of accept. */
7189 while (fd
== -512 || (fd
== -1 && errno
== EINTR
));
7193 warning ("Accept returned %d, error: %s\n",
7194 fd
, strerror (errno
));
7200 ret
= read (fd
, buf
, 1);
7201 } while (ret
== -1 && errno
== EINTR
);
7205 warning ("reading socket (fd=%d) failed with %s",
7206 fd
, strerror (errno
));
7213 if (startswith (cmd_buf
, "close"))
7218 else if (strcmp ("qTfSTM", cmd_buf
) == 0)
7220 cmd_qtfstm (cmd_buf
);
7222 else if (strcmp ("qTsSTM", cmd_buf
) == 0)
7224 cmd_qtsstm (cmd_buf
);
7226 else if (startswith (cmd_buf
, "unprobe_marker_at:"))
7228 unprobe_marker_at (cmd_buf
);
7230 else if (startswith (cmd_buf
, "probe_marker_at:"))
7232 probe_marker_at (cmd_buf
);
7234 else if (startswith (cmd_buf
, "qTSTMat:"))
7236 cmd_qtstmat (cmd_buf
);
7238 #endif /* HAVE_UST */
7241 /* Fix compiler's warning: ignoring return value of 'write'. */
7242 ret
= write (fd
, buf
, 1);
7248 unlink (agent_socket_name
);
7250 /* Sleep endlessly to wait the whole inferior stops. This
7251 thread can not exit because GDB or GDBserver may still need
7252 'current_thread' (representing this thread) to access
7253 inferior memory. Otherwise, this thread exits earlier than
7254 other threads, and 'current_thread' is set to NULL. */
7265 #include <pthread.h>
7268 IP_AGENT_EXPORT_VAR
int gdb_agent_capability
= AGENT_CAPA_STATIC_TRACE
;
7272 gdb_agent_init (void)
7279 /* We want the helper thread to be as transparent as possible, so
7280 have it inherit an all-signals-blocked mask. */
7282 sigfillset (&new_mask
);
7283 res
= pthread_sigmask (SIG_SETMASK
, &new_mask
, &orig_mask
);
7285 perror_with_name ("pthread_sigmask (1)");
7287 res
= pthread_create (&thread
,
7289 gdb_agent_helper_thread
,
7292 res
= pthread_sigmask (SIG_SETMASK
, &orig_mask
, NULL
);
7294 perror_with_name ("pthread_sigmask (2)");
7296 while (helper_thread_id
== 0)
7304 #include <sys/mman.h>
7307 IP_AGENT_EXPORT_VAR
char *gdb_tp_heap_buffer
;
7308 IP_AGENT_EXPORT_VAR
char *gdb_jump_pad_buffer
;
7309 IP_AGENT_EXPORT_VAR
char *gdb_jump_pad_buffer_end
;
7310 IP_AGENT_EXPORT_VAR
char *gdb_trampoline_buffer
;
7311 IP_AGENT_EXPORT_VAR
char *gdb_trampoline_buffer_end
;
7312 IP_AGENT_EXPORT_VAR
char *gdb_trampoline_buffer_error
;
7314 /* Record the result of getting buffer space for fast tracepoint
7315 trampolines. Any error message is copied, since caller may not be
7316 using persistent storage. */
7319 set_trampoline_buffer_space (CORE_ADDR begin
, CORE_ADDR end
, char *errmsg
)
7321 gdb_trampoline_buffer
= (char *) (uintptr_t) begin
;
7322 gdb_trampoline_buffer_end
= (char *) (uintptr_t) end
;
7324 strncpy (gdb_trampoline_buffer_error
, errmsg
, 99);
7326 strcpy (gdb_trampoline_buffer_error
, "no buffer passed");
7329 static void __attribute__ ((constructor
))
7330 initialize_tracepoint_ftlib (void)
7332 initialize_tracepoint ();
7337 #endif /* IN_PROCESS_AGENT */
7339 /* Return a timestamp, expressed as microseconds of the usual Unix
7340 time. (As the result is a 64-bit number, it will not overflow any
7344 get_timestamp (void)
7348 if (gettimeofday (&tv
, 0) != 0)
7351 return (LONGEST
) tv
.tv_sec
* 1000000 + tv
.tv_usec
;
7355 initialize_tracepoint (void)
7357 /* Start with the default size. */
7358 init_trace_buffer (DEFAULT_TRACE_BUFFER_SIZE
);
7360 /* Wire trace state variable 1 to be the timestamp. This will be
7361 uploaded to GDB upon connection and become one of its trace state
7362 variables. (In case you're wondering, if GDB already has a trace
7363 variable numbered 1, it will be renumbered.) */
7364 create_trace_state_variable (1, 0);
7365 set_trace_state_variable_name (1, "trace_timestamp");
7366 set_trace_state_variable_getter (1, get_timestamp
);
7368 #ifdef IN_PROCESS_AGENT
7373 pagesize
= sysconf (_SC_PAGE_SIZE
);
7375 perror_with_name ("sysconf");
7377 gdb_tp_heap_buffer
= (char *) xmalloc (5 * 1024 * 1024);
7379 #define SCRATCH_BUFFER_NPAGES 20
7381 /* Allocate scratch buffer aligned on a page boundary, at a low
7382 address (close to the main executable's code). */
7383 for (addr
= pagesize
; addr
!= 0; addr
+= pagesize
)
7386 = (char *) mmap ((void *) addr
,
7387 pagesize
* SCRATCH_BUFFER_NPAGES
,
7388 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
7389 MAP_PRIVATE
| MAP_ANONYMOUS
| MAP_FIXED
,
7391 if (gdb_jump_pad_buffer
!= MAP_FAILED
)
7396 perror_with_name ("mmap");
7398 gdb_jump_pad_buffer_end
= gdb_jump_pad_buffer
+ pagesize
* SCRATCH_BUFFER_NPAGES
;
7401 gdb_trampoline_buffer
= gdb_trampoline_buffer_end
= 0;
7403 /* It's not a fatal error for something to go wrong with trampoline
7404 buffer setup, but it can be mysterious, so create a channel to
7405 report back on what went wrong, using a fixed size since we may
7406 not be able to allocate space later when the problem occurs. */
7407 gdb_trampoline_buffer_error
= (char *) xmalloc (IPA_BUFSIZ
);
7409 strcpy (gdb_trampoline_buffer_error
, "No errors reported");
7411 initialize_low_tracepoint ();