1 /* Tracepoint code for remote server for GDB.
2 Copyright (C) 2009, 2010, 2011 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/>. */
29 /* This file is built for both GDBserver, and the in-process
30 agent (IPA), a shared library that includes a tracing agent that is
31 loaded by the inferior to support fast tracepoints. Fast
32 tracepoints (or more accurately, jump based tracepoints) are
33 implemented by patching the tracepoint location with a jump into a
34 small trampoline function whose job is to save the register state,
35 call the in-process tracing agent, and then execute the original
36 instruction that was under the tracepoint jump (possibly adjusted,
37 if PC-relative, or some such).
39 The current synchronization design is pull based. That means,
40 GDBserver does most of the work, by peeking/poking at the inferior
41 agent's memory directly for downloading tracepoint and associated
42 objects, and for uploading trace frames. Whenever the IPA needs
43 something from GDBserver (trace buffer is full, tracing stopped for
44 some reason, etc.) the IPA calls a corresponding hook function
45 where GDBserver has placed a breakpoint.
47 Each of the agents has its own trace buffer. When browsing the
48 trace frames built from slow and fast tracepoints from GDB (tfind
49 mode), there's no guarantee the user is seeing the trace frames in
50 strict chronological creation order, although, GDBserver tries to
51 keep the order relatively reasonable, by syncing the trace buffers
56 static void trace_vdebug (const char *, ...) ATTR_FORMAT (printf
, 1, 2);
59 trace_vdebug (const char *fmt
, ...)
65 vsprintf (buf
, fmt
, ap
);
66 fprintf (stderr
, "gdbserver/tracepoint: %s\n", buf
);
70 #define trace_debug_1(level, fmt, args...) \
72 if (level <= debug_threads) \
73 trace_vdebug ((fmt), ##args); \
76 #define trace_debug(FMT, args...) \
77 trace_debug_1 (1, FMT, ##args)
80 # define ATTR_USED __attribute__((used))
81 # define ATTR_NOINLINE __attribute__((noinline))
82 # define ATTR_CONSTRUCTOR __attribute__ ((constructor))
85 # define ATTR_NOINLINE
86 # define ATTR_CONSTRUCTOR
89 /* Make sure the functions the IPA needs to export (symbols GDBserver
90 needs to query GDB about) are exported. */
92 #ifdef IN_PROCESS_AGENT
93 # if defined _WIN32 || defined __CYGWIN__
94 # define IP_AGENT_EXPORT __declspec(dllexport) ATTR_USED
97 # define IP_AGENT_EXPORT \
98 __attribute__ ((visibility("default"))) ATTR_USED
100 # define IP_AGENT_EXPORT ATTR_USED
104 # define IP_AGENT_EXPORT
107 /* Prefix exported symbols, for good citizenship. All the symbols
108 that need exporting are defined in this module. */
109 #ifdef IN_PROCESS_AGENT
110 # define gdb_tp_heap_buffer gdb_agent_gdb_tp_heap_buffer
111 # define gdb_jump_pad_buffer gdb_agent_gdb_jump_pad_buffer
112 # define gdb_jump_pad_buffer_end gdb_agent_gdb_jump_pad_buffer_end
113 # define collecting gdb_agent_collecting
114 # define gdb_collect gdb_agent_gdb_collect
115 # define stop_tracing gdb_agent_stop_tracing
116 # define flush_trace_buffer gdb_agent_flush_trace_buffer
117 # define about_to_request_buffer_space gdb_agent_about_to_request_buffer_space
118 # define trace_buffer_is_full gdb_agent_trace_buffer_is_full
119 # define stopping_tracepoint gdb_agent_stopping_tracepoint
120 # define expr_eval_result gdb_agent_expr_eval_result
121 # define error_tracepoint gdb_agent_error_tracepoint
122 # define tracepoints gdb_agent_tracepoints
123 # define tracing gdb_agent_tracing
124 # define trace_buffer_ctrl gdb_agent_trace_buffer_ctrl
125 # define trace_buffer_ctrl_curr gdb_agent_trace_buffer_ctrl_curr
126 # define trace_buffer_lo gdb_agent_trace_buffer_lo
127 # define trace_buffer_hi gdb_agent_trace_buffer_hi
128 # define traceframe_read_count gdb_agent_traceframe_read_count
129 # define traceframe_write_count gdb_agent_traceframe_write_count
130 # define traceframes_created gdb_agent_traceframes_created
131 # define trace_state_variables gdb_agent_trace_state_variables
132 # define get_raw_reg gdb_agent_get_raw_reg
133 # define get_trace_state_variable_value \
134 gdb_agent_get_trace_state_variable_value
135 # define set_trace_state_variable_value \
136 gdb_agent_set_trace_state_variable_value
137 # define ust_loaded gdb_agent_ust_loaded
138 # define helper_thread_id gdb_agent_helper_thread_id
139 # define cmd_buf gdb_agent_cmd_buf
142 #ifndef IN_PROCESS_AGENT
144 /* Addresses of in-process agent's symbols GDBserver cares about. */
146 struct ipa_sym_addresses
148 CORE_ADDR addr_gdb_tp_heap_buffer
;
149 CORE_ADDR addr_gdb_jump_pad_buffer
;
150 CORE_ADDR addr_gdb_jump_pad_buffer_end
;
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
;
174 CORE_ADDR addr_helper_thread_id
;
175 CORE_ADDR addr_cmd_buf
;
178 #define STRINGIZE_1(STR) #STR
179 #define STRINGIZE(STR) STRINGIZE_1(STR)
180 #define IPA_SYM(SYM) \
182 STRINGIZE (gdb_agent_ ## SYM), \
183 offsetof (struct ipa_sym_addresses, addr_ ## SYM) \
192 IPA_SYM(gdb_tp_heap_buffer
),
193 IPA_SYM(gdb_jump_pad_buffer
),
194 IPA_SYM(gdb_jump_pad_buffer_end
),
196 IPA_SYM(gdb_collect
),
197 IPA_SYM(stop_tracing
),
198 IPA_SYM(flush_trace_buffer
),
199 IPA_SYM(about_to_request_buffer_space
),
200 IPA_SYM(trace_buffer_is_full
),
201 IPA_SYM(stopping_tracepoint
),
202 IPA_SYM(expr_eval_result
),
203 IPA_SYM(error_tracepoint
),
204 IPA_SYM(tracepoints
),
206 IPA_SYM(trace_buffer_ctrl
),
207 IPA_SYM(trace_buffer_ctrl_curr
),
208 IPA_SYM(trace_buffer_lo
),
209 IPA_SYM(trace_buffer_hi
),
210 IPA_SYM(traceframe_read_count
),
211 IPA_SYM(traceframe_write_count
),
212 IPA_SYM(traceframes_created
),
213 IPA_SYM(trace_state_variables
),
214 IPA_SYM(get_raw_reg
),
215 IPA_SYM(get_trace_state_variable_value
),
216 IPA_SYM(set_trace_state_variable_value
),
218 IPA_SYM(helper_thread_id
),
222 struct ipa_sym_addresses ipa_sym_addrs
;
224 int all_tracepoint_symbols_looked_up
;
227 in_process_agent_loaded (void)
229 return all_tracepoint_symbols_looked_up
;
232 static int read_inferior_integer (CORE_ADDR symaddr
, int *val
);
234 /* Returns true if both the in-process agent library and the static
235 tracepoints libraries are loaded in the inferior. */
238 in_process_agent_loaded_ust (void)
242 if (!in_process_agent_loaded ())
244 warning ("In-process agent not loaded");
248 if (read_inferior_integer (ipa_sym_addrs
.addr_ust_loaded
, &loaded
))
250 warning ("Error reading ust_loaded in lib");
258 write_e_ipa_not_loaded (char *buffer
)
261 "E.In-process agent library not loaded in process. "
262 "Fast and static tracepoints unavailable.");
265 /* Write an error to BUFFER indicating that UST isn't loaded in the
269 write_e_ust_not_loaded (char *buffer
)
273 "E.UST library not loaded in process. "
274 "Static tracepoints unavailable.");
276 sprintf (buffer
, "E.GDBserver was built without static tracepoints support");
280 /* If the in-process agent library isn't loaded in the inferior, write
281 an error to BUFFER, and return 1. Otherwise, return 0. */
284 maybe_write_ipa_not_loaded (char *buffer
)
286 if (!in_process_agent_loaded ())
288 write_e_ipa_not_loaded (buffer
);
294 /* If the in-process agent library and the ust (static tracepoints)
295 library aren't loaded in the inferior, write an error to BUFFER,
296 and return 1. Otherwise, return 0. */
299 maybe_write_ipa_ust_not_loaded (char *buffer
)
301 if (!in_process_agent_loaded ())
303 write_e_ipa_not_loaded (buffer
);
306 else if (!in_process_agent_loaded_ust ())
308 write_e_ust_not_loaded (buffer
);
314 /* Cache all future symbols that the tracepoints module might request.
315 We can not request symbols at arbitrary states in the remote
316 protocol, only when the client tells us that new symbols are
317 available. So when we load the in-process library, make sure to
318 check the entire list. */
321 tracepoint_look_up_symbols (void)
326 if (all_tracepoint_symbols_looked_up
)
330 for (i
= 0; i
< sizeof (symbol_list
) / sizeof (symbol_list
[0]); i
++)
333 (CORE_ADDR
*) ((char *) &ipa_sym_addrs
+ symbol_list
[i
].offset
);
335 if (look_up_one_symbol (symbol_list
[i
].name
, addrp
, 1) == 0)
338 fprintf (stderr
, "symbol `%s' not found\n", symbol_list
[i
].name
);
343 all_tracepoint_symbols_looked_up
= all_ok
;
348 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
349 of the "stop_tracing" function. When this breakpoint is hit,
350 tracing stopped in the IPA for some reason. E.g., due to
351 tracepoint reaching the pass count, hitting conditional expression
352 evaluation error, etc.
354 The IPA's trace buffer is never in circular tracing mode: instead,
355 GDBserver's is, and whenever the in-process buffer fills, it calls
356 "flush_trace_buffer", which triggers an internal breakpoint.
357 GDBserver reacts to this breakpoint by pulling the meanwhile
358 collected data. Old frames discarding is always handled on the
361 #ifdef IN_PROCESS_AGENT
362 int debug_threads
= 0;
365 read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
367 memcpy (myaddr
, (void *) (uintptr_t) memaddr
, len
);
371 /* Call this in the functions where GDBserver places a breakpoint, so
372 that the compiler doesn't try to be clever and skip calling the
373 function at all. This is necessary, even if we tell the compiler
374 to not inline said functions. */
376 #if defined(__GNUC__)
377 # define UNKNOWN_SIDE_EFFECTS() asm ("")
379 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
382 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
385 /* GDBserver places breakpoint here. */
386 UNKNOWN_SIDE_EFFECTS();
389 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
390 flush_trace_buffer (void)
392 /* GDBserver places breakpoint here. */
393 UNKNOWN_SIDE_EFFECTS();
398 #ifndef IN_PROCESS_AGENT
400 tracepoint_handler (CORE_ADDR address
)
402 trace_debug ("tracepoint_handler: tracepoint at 0x%s hit",
407 /* Breakpoint at "stop_tracing" in the inferior lib. */
408 struct breakpoint
*stop_tracing_bkpt
;
409 static int stop_tracing_handler (CORE_ADDR
);
411 /* Breakpoint at "flush_trace_buffer" in the inferior lib. */
412 struct breakpoint
*flush_trace_buffer_bkpt
;
413 static int flush_trace_buffer_handler (CORE_ADDR
);
415 static void download_tracepoints (void);
416 static void download_trace_state_variables (void);
417 static void upload_fast_traceframes (void);
419 static int run_inferior_command (char *cmd
);
422 read_inferior_integer (CORE_ADDR symaddr
, int *val
)
424 return read_inferior_memory (symaddr
, (unsigned char *) val
,
429 read_inferior_uinteger (CORE_ADDR symaddr
, unsigned int *val
)
431 return read_inferior_memory (symaddr
, (unsigned char *) val
,
436 read_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR
*val
)
438 void *pval
= (void *) (uintptr_t) val
;
441 ret
= read_inferior_memory (symaddr
, (unsigned char *) &pval
, sizeof (pval
));
442 *val
= (uintptr_t) pval
;
447 write_inferior_data_pointer (CORE_ADDR symaddr
, CORE_ADDR val
)
449 void *pval
= (void *) (uintptr_t) val
;
450 return write_inferior_memory (symaddr
,
451 (unsigned char *) &pval
, sizeof (pval
));
455 write_inferior_integer (CORE_ADDR symaddr
, int val
)
457 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
461 write_inferior_uinteger (CORE_ADDR symaddr
, unsigned int val
)
463 return write_inferior_memory (symaddr
, (unsigned char *) &val
, sizeof (val
));
468 /* This enum must exactly match what is documented in
469 gdb/doc/agentexpr.texi, including all the numerical values. */
473 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
474 gdb_agent_op_ ## NAME = VALUE,
480 static const char *gdb_agent_op_names
[gdb_agent_op_last
] =
483 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) , # NAME
492 unsigned char *bytes
;
495 /* Base action. Concrete actions inherit this. */
497 struct tracepoint_action
502 /* An 'M' (collect memory) action. */
503 struct collect_memory_action
505 struct tracepoint_action base
;
512 /* An 'R' (collect registers) action. */
514 struct collect_registers_action
516 struct tracepoint_action base
;
519 /* An 'X' (evaluate expression) action. */
521 struct eval_expr_action
523 struct tracepoint_action base
;
525 struct agent_expr
*expr
;
528 /* An 'L' (collect static trace data) action. */
529 struct collect_static_trace_data_action
531 struct tracepoint_action base
;
534 /* This structure describes a piece of the source-level definition of
535 the tracepoint. The contents are not interpreted by the target,
536 but preserved verbatim for uploading upon reconnection. */
540 /* The type of string, such as "cond" for a conditional. */
543 /* The source-level string itself. For the sake of target
544 debugging, we store it in plaintext, even though it is always
545 transmitted in hex. */
548 /* Link to the next one in the list. We link them in the order
549 received, in case some make up an ordered list of commands or
551 struct source_string
*next
;
556 /* Trap based tracepoint. */
559 /* A fast tracepoint implemented with a jump instead of a trap. */
562 /* A static tracepoint, implemented by a program call into a tracing
567 struct tracepoint_hit_ctx
;
569 typedef enum eval_result_type (*condfn
) (struct tracepoint_hit_ctx
*,
572 /* The definition of a tracepoint. */
574 /* Tracepoints may have multiple locations, each at a different
575 address. This can occur with optimizations, template
576 instantiation, etc. Since the locations may be in different
577 scopes, the conditions and actions may be different for each
578 location. Our target version of tracepoints is more like GDB's
579 notion of "breakpoint locations", but we have almost nothing that
580 is not per-location, so we bother having two kinds of objects. The
581 key consequence is that numbers are not unique, and that it takes
582 both number and address to identify a tracepoint uniquely. */
586 /* The number of the tracepoint, as specified by GDB. Several
587 tracepoint objects here may share a number. */
590 /* Address at which the tracepoint is supposed to trigger. Several
591 tracepoints may share an address. */
594 /* Tracepoint type. */
595 enum tracepoint_type type
;
597 /* True if the tracepoint is currently enabled. */
600 /* The number of single steps that will be performed after each
604 /* The number of times the tracepoint may be hit before it will
605 terminate the entire tracing run. */
608 /* Pointer to the agent expression that is the tracepoint's
609 conditional, or NULL if the tracepoint is unconditional. */
610 struct agent_expr
*cond
;
612 /* The list of actions to take when the tracepoint triggers. */
614 struct tracepoint_action
**actions
;
616 /* Count of the times we've hit this tracepoint during the run.
617 Note that while-stepping steps are not counted as "hits". */
620 CORE_ADDR compiled_cond
;
622 /* Link to the next tracepoint in the list. */
623 struct tracepoint
*next
;
625 #ifndef IN_PROCESS_AGENT
626 /* The list of actions to take when the tracepoint triggers, in
627 string/packet form. */
630 /* The collection of strings that describe the tracepoint as it was
631 entered into GDB. These are not used by the target, but are
632 reported back to GDB upon reconnection. */
633 struct source_string
*source_strings
;
635 /* The number of bytes displaced by fast tracepoints. It may subsume
636 multiple instructions, for multi-byte fast tracepoints. This
637 field is only valid for fast tracepoints. */
640 /* Only for fast tracepoints. */
641 CORE_ADDR obj_addr_on_target
;
643 /* Address range where the original instruction under a fast
644 tracepoint was relocated to. (_end is actually one byte past
646 CORE_ADDR adjusted_insn_addr
;
647 CORE_ADDR adjusted_insn_addr_end
;
649 /* The address range of the piece of the jump pad buffer that was
650 assigned to this fast tracepoint. (_end is actually one byte
653 CORE_ADDR jump_pad_end
;
655 /* The list of actions to take while in a stepping loop. These
656 fields are only valid for patch-based tracepoints. */
657 int num_step_actions
;
658 struct tracepoint_action
**step_actions
;
659 /* Same, but in string/packet form. */
660 char **step_actions_str
;
662 /* Handle returned by the breakpoint or tracepoint module when we
663 inserted the trap or jump, or hooked into a static tracepoint.
664 NULL if we haven't inserted it yet. */
670 #ifndef IN_PROCESS_AGENT
672 /* Given `while-stepping', a thread may be collecting data for more
673 than one tracepoint simultaneously. On the other hand, the same
674 tracepoint with a while-stepping action may be hit by more than one
675 thread simultaneously (but not quite, each thread could be handling
676 a different step). Each thread holds a list of these objects,
677 representing the current step of each while-stepping action being
682 struct wstep_state
*next
;
684 /* The tracepoint number. */
686 /* The tracepoint's address. */
687 CORE_ADDR tp_address
;
689 /* The number of the current step in this 'while-stepping'
696 /* The linked list of all tracepoints. Marked explicitly as used as
697 the in-process library doesn't use it for the fast tracepoints
699 IP_AGENT_EXPORT
struct tracepoint
*tracepoints ATTR_USED
;
701 #ifndef IN_PROCESS_AGENT
703 /* Pointer to the last tracepoint in the list, new tracepoints are
704 linked in at the end. */
706 static struct tracepoint
*last_tracepoint
;
709 /* The first tracepoint to exceed its pass count. */
711 IP_AGENT_EXPORT
struct tracepoint
*stopping_tracepoint
;
713 /* True if the trace buffer is full or otherwise no longer usable. */
715 IP_AGENT_EXPORT
int trace_buffer_is_full
;
717 /* Enumeration of the different kinds of things that can happen during
718 agent expression evaluation. */
720 enum eval_result_type
723 expr_eval_empty_expression
,
724 expr_eval_empty_stack
,
725 expr_eval_stack_overflow
,
726 expr_eval_stack_underflow
,
727 expr_eval_unhandled_opcode
,
728 expr_eval_unrecognized_opcode
,
729 expr_eval_divide_by_zero
,
730 expr_eval_invalid_goto
733 static enum eval_result_type expr_eval_result
= expr_eval_no_error
;
735 #ifndef IN_PROCESS_AGENT
737 static const char *eval_result_names
[] =
739 "terror:in the attic", /* this should never be reported */
740 "terror:empty expression",
741 "terror:empty stack",
742 "terror:stack overflow",
743 "terror:stack underflow",
744 "terror:unhandled opcode",
745 "terror:unrecognized opcode",
746 "terror:divide by zero"
751 /* The tracepoint in which the error occurred. */
753 static struct tracepoint
*error_tracepoint
;
755 struct trace_state_variable
757 /* This is the name of the variable as used in GDB. The target
758 doesn't use the name, but needs to have it for saving and
759 reconnection purposes. */
762 /* This number identifies the variable uniquely. Numbers may be
763 assigned either by the target (in the case of builtin variables),
764 or by GDB, and are presumed unique during the course of a trace
768 /* The variable's initial value, a 64-bit signed integer always. */
769 LONGEST initial_value
;
771 /* The variable's value, a 64-bit signed integer always. */
774 /* Pointer to a getter function, used to supply computed values. */
775 LONGEST (*getter
) (void);
777 /* Link to the next variable. */
778 struct trace_state_variable
*next
;
781 /* Linked list of all trace state variables. */
783 #ifdef IN_PROCESS_AGENT
784 struct trace_state_variable
*alloced_trace_state_variables
;
787 IP_AGENT_EXPORT
struct trace_state_variable
*trace_state_variables
;
789 /* The results of tracing go into a fixed-size space known as the
790 "trace buffer". Because usage follows a limited number of
791 patterns, we manage it ourselves rather than with malloc. Basic
792 rules are that we create only one trace frame at a time, each is
793 variable in size, they are never moved once created, and we only
794 discard if we are doing a circular buffer, and then only the oldest
795 ones. Each trace frame includes its own size, so we don't need to
796 link them together, and the trace frame number is relative to the
797 first one, so we don't need to record numbers. A trace frame also
798 records the number of the tracepoint that created it. The data
799 itself is a series of blocks, each introduced by a single character
800 and with a defined format. Each type of block has enough
801 type/length info to allow scanners to jump quickly from one block
802 to the next without reading each byte in the block. */
804 /* Trace buffer management would be simple - advance a free pointer
805 from beginning to end, then stop - were it not for the circular
806 buffer option, which is a useful way to prevent a trace run from
807 stopping prematurely because the buffer filled up. In the circular
808 case, the location of the first trace frame (trace_buffer_start)
809 moves as old trace frames are discarded. Also, since we grow trace
810 frames incrementally as actions are performed, we wrap around to
811 the beginning of the trace buffer. This is per-block, so each
812 block within a trace frame remains contiguous. Things get messy
813 when the wrapped-around trace frame is the one being discarded; the
814 free space ends up in two parts at opposite ends of the buffer. */
817 # if defined(__GNUC__)
818 # define ATTR_PACKED __attribute__ ((packed))
820 # define ATTR_PACKED /* nothing */
824 /* The data collected at a tracepoint hit. This object should be as
825 small as possible, since there may be a great many of them. We do
826 not need to keep a frame number, because they are all sequential
827 and there are no deletions; so the Nth frame in the buffer is
828 always frame number N. */
832 /* Number of the tracepoint that collected this traceframe. A value
833 of 0 indicates the current end of the trace buffer. We make this
834 a 16-bit field because it's never going to happen that GDB's
835 numbering of tracepoints reaches 32,000. */
838 /* The size of the data in this trace frame. We limit this to 32
839 bits, even on a 64-bit target, because it's just implausible that
840 one is validly going to collect 4 gigabytes of data at a single
842 unsigned int data_size
: 32;
844 /* The base of the trace data, which is contiguous from this point. */
845 unsigned char data
[0];
849 /* The traceframe to be used as the source of data to send back to
850 GDB. A value of -1 means to get data from the live program. */
852 int current_traceframe
= -1;
854 /* This flag is true if the trace buffer is circular, meaning that
855 when it fills, the oldest trace frames are discarded in order to
858 #ifndef IN_PROCESS_AGENT
859 static int circular_trace_buffer
;
862 /* Pointer to the block of memory that traceframes all go into. */
864 static unsigned char *trace_buffer_lo
;
866 /* Pointer to the end of the trace buffer, more precisely to the byte
867 after the end of the buffer. */
869 static unsigned char *trace_buffer_hi
;
871 /* Control structure holding the read/write/etc. pointers into the
872 trace buffer. We need more than one of these to implement a
873 transaction-like mechanism to garantees that both GDBserver and the
874 in-process agent can try to change the trace buffer
877 struct trace_buffer_control
879 /* Pointer to the first trace frame in the buffer. In the
880 non-circular case, this is equal to trace_buffer_lo, otherwise it
881 moves around in the buffer. */
882 unsigned char *start
;
884 /* Pointer to the free part of the trace buffer. Note that we clear
885 several bytes at and after this pointer, so that traceframe
886 scans/searches terminate properly. */
889 /* Pointer to the byte after the end of the free part. Note that
890 this may be smaller than trace_buffer_free in the circular case,
891 and means that the free part is in two pieces. Initially it is
892 equal to trace_buffer_hi, then is generally equivalent to
893 trace_buffer_start. */
894 unsigned char *end_free
;
896 /* Pointer to the wraparound. If not equal to trace_buffer_hi, then
897 this is the point at which the trace data breaks, and resumes at
902 /* Same as above, to be used by GDBserver when updating the in-process
904 struct ipa_trace_buffer_control
913 /* We have possibly both GDBserver and an inferior thread accessing
914 the same IPA trace buffer memory. The IPA is the producer (tries
915 to put new frames in the buffer), while GDBserver occasionally
916 consumes them, that is, flushes the IPA's buffer into its own
917 buffer. Both sides need to update the trace buffer control
918 pointers (current head, tail, etc.). We can't use a global lock to
919 synchronize the accesses, as otherwise we could deadlock GDBserver
920 (if the thread holding the lock stops for a signal, say). So
921 instead of that, we use a transaction scheme where GDBserver writes
922 always prevail over the IPAs writes, and, we have the IPA detect
923 the commit failure/overwrite, and retry the whole attempt. This is
924 mainly implemented by having a global token object that represents
925 who wrote last to the buffer control structure. We need to freeze
926 any inferior writing to the buffer while GDBserver touches memory,
927 so that the inferior can correctly detect that GDBserver had been
928 there, otherwise, it could mistakingly think its commit was
929 successful; that's implemented by simply having GDBserver set a
930 breakpoint the inferior hits if it is the critical region.
932 There are three cycling trace buffer control structure copies
933 (buffer head, tail, etc.), with the token object including an index
934 indicating which is current live copy. The IPA tentatively builds
935 an updated copy in a non-current control structure, while GDBserver
936 always clobbers the current version directly. The IPA then tries
937 to atomically "commit" its version; if GDBserver clobbered the
938 structure meanwhile, that will fail, and the IPA restarts the
941 Listing the step in further detail, we have:
943 In-process agent (producer):
945 - passes by `about_to_request_buffer_space' breakpoint/lock
947 - reads current token, extracts current trace buffer control index,
948 and starts tentatively updating the rightmost one (0->1, 1->2,
949 2->0). Note that only one inferior thread is executing this code
950 at any given time, due to an outer lock in the jump pads.
952 - updates counters, and tries to commit the token.
954 - passes by second `about_to_request_buffer_space' breakpoint/lock,
955 leaving the sync region.
957 - checks if the update was effective.
959 - if trace buffer was found full, hits flush_trace_buffer
960 breakpoint, and restarts later afterwards.
962 GDBserver (consumer):
964 - sets `about_to_request_buffer_space' breakpoint/lock.
966 - updates the token unconditionally, using the current buffer
967 control index, since it knows that the IP agent always writes to
968 the rightmost, and due to the breakpoint, at most one IP thread
969 can try to update the trace buffer concurrently to GDBserver, so
970 there will be no danger of trace buffer control index wrap making
971 the IPA write to the same index as GDBserver.
973 - flushes the IP agent's trace buffer completely, and updates the
974 current trace buffer control structure. GDBserver *always* wins.
976 - removes the `about_to_request_buffer_space' breakpoint.
978 The token is stored in the `trace_buffer_ctrl_curr' variable.
979 Internally, it's bits are defined as:
981 |-------------+-----+-------------+--------+-------------+--------------|
982 | Bit offsets | 31 | 30 - 20 | 19 | 18-8 | 7-0 |
983 |-------------+-----+-------------+--------+-------------+--------------|
984 | What | GSB | PC (11-bit) | unused | CC (11-bit) | TBCI (8-bit) |
985 |-------------+-----+-------------+--------+-------------+--------------|
987 GSB - GDBserver Stamp Bit
988 PC - Previous Counter
990 TBCI - Trace Buffer Control Index
993 An IPA update of `trace_buffer_ctrl_curr' does:
995 - read CC from the current token, save as PC.
997 - atomically tries to write PC+1,CC
999 A GDBserver update of `trace_buffer_ctrl_curr' does:
1001 - reads PC and CC from the current token.
1006 /* These are the bits of `trace_buffer_ctrl_curr' that are reserved
1007 for the counters described below. The cleared bits are used to
1008 hold the index of the items of the `trace_buffer_ctrl' array that
1010 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1012 /* `trace_buffer_ctrl_curr' contains two counters. The `previous'
1013 counter, and the `current' counter. */
1015 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1016 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1018 /* When GDBserver update the IP agent's `trace_buffer_ctrl_curr', it
1019 always stamps this bit as set. */
1020 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1022 #ifdef IN_PROCESS_AGENT
1023 IP_AGENT_EXPORT
struct trace_buffer_control trace_buffer_ctrl
[3];
1024 IP_AGENT_EXPORT
unsigned int trace_buffer_ctrl_curr
;
1026 # define TRACE_BUFFER_CTRL_CURR \
1027 (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1031 /* The GDBserver side agent only needs one instance of this object, as
1032 it doesn't need to sync with itself. Define it as array anyway so
1033 that the rest of the code base doesn't need to care for the
1035 struct trace_buffer_control trace_buffer_ctrl
[1];
1036 # define TRACE_BUFFER_CTRL_CURR 0
1039 /* These are convenience macros used to access the current trace
1040 buffer control in effect. */
1041 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1042 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1043 #define trace_buffer_end_free \
1044 (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1045 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1048 /* Macro that returns a pointer to the first traceframe in the buffer. */
1050 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1052 /* Macro that returns a pointer to the next traceframe in the buffer.
1053 If the computed location is beyond the wraparound point, subtract
1054 the offset of the wraparound. */
1056 #define NEXT_TRACEFRAME_1(TF) \
1057 (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1059 #define NEXT_TRACEFRAME(TF) \
1060 ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1061 - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1062 ? (trace_buffer_wrap - trace_buffer_lo) \
1065 /* The difference between these counters represents the total number
1066 of complete traceframes present in the trace buffer. The IP agent
1067 writes to the write count, GDBserver writes to read count. */
1069 IP_AGENT_EXPORT
unsigned int traceframe_write_count
;
1070 IP_AGENT_EXPORT
unsigned int traceframe_read_count
;
1072 /* Convenience macro. */
1074 #define traceframe_count \
1075 ((unsigned int) (traceframe_write_count - traceframe_read_count))
1077 /* The count of all traceframes created in the current run, including
1078 ones that were discarded to make room. */
1080 IP_AGENT_EXPORT
int traceframes_created
;
1082 #ifndef IN_PROCESS_AGENT
1084 /* Read-only regions are address ranges whose contents don't change,
1085 and so can be read from target memory even while looking at a trace
1086 frame. Without these, disassembly for instance will likely fail,
1087 because the program code is not usually collected into a trace
1088 frame. This data structure does not need to be very complicated or
1089 particularly efficient, it's only going to be used occasionally,
1090 and only by some commands. */
1092 struct readonly_region
1094 /* The bounds of the region. */
1095 CORE_ADDR start
, end
;
1097 /* Link to the next one. */
1098 struct readonly_region
*next
;
1101 /* Linked list of readonly regions. This list stays in effect from
1102 one tstart to the next. */
1104 static struct readonly_region
*readonly_regions
;
1108 /* The global that controls tracing overall. */
1110 IP_AGENT_EXPORT
int tracing
;
1112 #ifndef IN_PROCESS_AGENT
1114 /* Controls whether tracing should continue after GDB disconnects. */
1116 int disconnected_tracing
;
1118 /* The reason for the last tracing run to have stopped. We initialize
1119 to a distinct string so that GDB can distinguish between "stopped
1120 after running" and "stopped because never run" cases. */
1122 static const char *tracing_stop_reason
= "tnotrun";
1124 static int tracing_stop_tpnum
;
1128 /* Functions local to this file. */
1130 /* Base "class" for tracepoint type specific data to be passed down to
1131 collect_data_at_tracepoint. */
1132 struct tracepoint_hit_ctx
1134 enum tracepoint_type type
;
1137 #ifdef IN_PROCESS_AGENT
1139 /* Fast/jump tracepoint specific data to be passed down to
1140 collect_data_at_tracepoint. */
1141 struct fast_tracepoint_ctx
1143 struct tracepoint_hit_ctx base
;
1145 struct regcache regcache
;
1146 int regcache_initted
;
1147 unsigned char *regspace
;
1149 unsigned char *regs
;
1150 struct tracepoint
*tpoint
;
1153 /* Static tracepoint specific data to be passed down to
1154 collect_data_at_tracepoint. */
1155 struct static_tracepoint_ctx
1157 struct tracepoint_hit_ctx base
;
1159 /* The regcache corresponding to the registers state at the time of
1160 the tracepoint hit. Initialized lazily, from REGS. */
1161 struct regcache regcache
;
1162 int regcache_initted
;
1164 /* The buffer space REGCACHE above uses. We use a separate buffer
1165 instead of letting the regcache malloc for both signal safety and
1166 performance reasons; this is allocated on the stack instead. */
1167 unsigned char *regspace
;
1169 /* The register buffer as passed on by lttng/ust. */
1170 struct registers
*regs
;
1172 /* The "printf" formatter and the args the user passed to the marker
1173 call. We use this to be able to collect "static trace data"
1178 /* The GDB tracepoint matching the probed marker that was "hit". */
1179 struct tracepoint
*tpoint
;
1184 /* Static tracepoint specific data to be passed down to
1185 collect_data_at_tracepoint. */
1186 struct trap_tracepoint_ctx
1188 struct tracepoint_hit_ctx base
;
1190 struct regcache
*regcache
;
1195 #ifndef IN_PROCESS_AGENT
1196 static struct agent_expr
*parse_agent_expr (char **actparm
);
1197 static char *unparse_agent_expr (struct agent_expr
*aexpr
);
1199 static enum eval_result_type
eval_agent_expr (struct tracepoint_hit_ctx
*ctx
,
1200 struct traceframe
*tframe
,
1201 struct agent_expr
*aexpr
,
1204 static int agent_mem_read (struct traceframe
*tframe
,
1205 unsigned char *to
, CORE_ADDR from
, ULONGEST len
);
1206 static int agent_tsv_read (struct traceframe
*tframe
, int n
);
1208 #ifndef IN_PROCESS_AGENT
1209 static CORE_ADDR
traceframe_get_pc (struct traceframe
*tframe
);
1210 static int traceframe_read_tsv (int num
, LONGEST
*val
);
1213 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1214 struct tracepoint
*tpoint
);
1216 #ifndef IN_PROCESS_AGENT
1217 static void clear_readonly_regions (void);
1218 static void clear_installed_tracepoints (void);
1221 static void collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1223 struct tracepoint
*tpoint
);
1224 #ifndef IN_PROCESS_AGENT
1225 static void collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
1227 struct tracepoint
*tpoint
, int current_step
);
1228 static void compile_tracepoint_condition (struct tracepoint
*tpoint
,
1229 CORE_ADDR
*jump_entry
);
1231 static void do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
1233 struct tracepoint
*tpoint
,
1234 struct traceframe
*tframe
,
1235 struct tracepoint_action
*taction
);
1237 #ifndef IN_PROCESS_AGENT
1238 static struct tracepoint
*fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR
);
1241 #if defined(__GNUC__)
1242 # define memory_barrier() asm volatile ("" : : : "memory")
1244 # define memory_barrier() do {} while (0)
1247 /* We only build the IPA if this builtin is supported, and there are
1248 no uses of this in GDBserver itself, so we're safe in defining this
1250 #define cmpxchg(mem, oldval, newval) \
1251 __sync_val_compare_and_swap (mem, oldval, newval)
1253 /* The size in bytes of the buffer used to talk to the IPA helper
1255 #define CMD_BUF_SIZE 1024
1257 /* Record that an error occurred during expression evaluation. */
1260 record_tracepoint_error (struct tracepoint
*tpoint
, const char *which
,
1261 enum eval_result_type rtype
)
1263 trace_debug ("Tracepoint %d at %s %s eval reports error %d",
1264 tpoint
->number
, paddress (tpoint
->address
), which
, rtype
);
1266 #ifdef IN_PROCESS_AGENT
1267 /* Only record the first error we get. */
1268 if (cmpxchg (&expr_eval_result
,
1270 rtype
) != expr_eval_no_error
)
1273 if (expr_eval_result
!= expr_eval_no_error
)
1277 error_tracepoint
= tpoint
;
1280 /* Trace buffer management. */
1283 clear_trace_buffer (void)
1285 trace_buffer_start
= trace_buffer_lo
;
1286 trace_buffer_free
= trace_buffer_lo
;
1287 trace_buffer_end_free
= trace_buffer_hi
;
1288 trace_buffer_wrap
= trace_buffer_hi
;
1289 /* A traceframe with zeroed fields marks the end of trace data. */
1290 ((struct traceframe
*) trace_buffer_free
)->tpnum
= 0;
1291 ((struct traceframe
*) trace_buffer_free
)->data_size
= 0;
1292 traceframe_read_count
= traceframe_write_count
= 0;
1293 traceframes_created
= 0;
1296 #ifndef IN_PROCESS_AGENT
1299 clear_inferior_trace_buffer (void)
1301 CORE_ADDR ipa_trace_buffer_lo
;
1302 CORE_ADDR ipa_trace_buffer_hi
;
1303 struct traceframe ipa_traceframe
= { 0 };
1304 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
1306 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
1307 &ipa_trace_buffer_lo
);
1308 read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
1309 &ipa_trace_buffer_hi
);
1311 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
1312 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
1313 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
1314 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
1316 /* A traceframe with zeroed fields marks the end of trace data. */
1317 write_inferior_memory (ipa_sym_addrs
.addr_trace_buffer_ctrl
,
1318 (unsigned char *) &ipa_trace_buffer_ctrl
,
1319 sizeof (ipa_trace_buffer_ctrl
));
1321 write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
, 0);
1323 /* A traceframe with zeroed fields marks the end of trace data. */
1324 write_inferior_memory (ipa_trace_buffer_lo
,
1325 (unsigned char *) &ipa_traceframe
,
1326 sizeof (ipa_traceframe
));
1328 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
, 0);
1329 write_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
, 0);
1330 write_inferior_integer (ipa_sym_addrs
.addr_traceframes_created
, 0);
1336 init_trace_buffer (unsigned char *buf
, int bufsize
)
1338 trace_buffer_lo
= buf
;
1339 trace_buffer_hi
= trace_buffer_lo
+ bufsize
;
1341 clear_trace_buffer ();
1344 #ifdef IN_PROCESS_AGENT
1346 IP_AGENT_EXPORT
void ATTR_USED ATTR_NOINLINE
1347 about_to_request_buffer_space (void)
1349 /* GDBserver places breakpoint here while it goes about to flush
1350 data at random times. */
1351 UNKNOWN_SIDE_EFFECTS();
1356 /* Carve out a piece of the trace buffer, returning NULL in case of
1360 trace_buffer_alloc (size_t amt
)
1362 unsigned char *rslt
;
1363 struct trace_buffer_control
*tbctrl
;
1365 #ifdef IN_PROCESS_AGENT
1366 unsigned int prev
, prev_filtered
;
1367 unsigned int commit_count
;
1368 unsigned int commit
;
1369 unsigned int readout
;
1371 struct traceframe
*oldest
;
1372 unsigned char *new_start
;
1375 trace_debug ("Want to allocate %ld+%ld bytes in trace buffer",
1376 (long) amt
, (long) sizeof (struct traceframe
));
1378 /* Account for the EOB marker. */
1379 amt
+= sizeof (struct traceframe
);
1381 #ifdef IN_PROCESS_AGENT
1385 /* Read the current token and extract the index to try to write to,
1386 storing it in CURR. */
1387 prev
= trace_buffer_ctrl_curr
;
1388 prev_filtered
= prev
& ~GDBSERVER_FLUSH_COUNT_MASK
;
1389 curr
= prev_filtered
+ 1;
1393 about_to_request_buffer_space ();
1395 /* Start out with a copy of the current state. GDBserver may be
1396 midway writing to the PREV_FILTERED TBC, but, that's OK, we won't
1397 be able to commit anyway if that happens. */
1398 trace_buffer_ctrl
[curr
]
1399 = trace_buffer_ctrl
[prev_filtered
];
1400 trace_debug ("trying curr=%u", curr
);
1402 /* The GDBserver's agent doesn't need all that syncing, and always
1403 updates TCB 0 (there's only one, mind you). */
1406 tbctrl
= &trace_buffer_ctrl
[curr
];
1408 /* Offsets are easier to grok for debugging than raw addresses,
1409 especially for the small trace buffer sizes that are useful for
1411 trace_debug ("Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1413 (int) (tbctrl
->start
- trace_buffer_lo
),
1414 (int) (tbctrl
->free
- trace_buffer_lo
),
1415 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1416 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1417 (int) (trace_buffer_hi
- trace_buffer_lo
));
1419 /* The algorithm here is to keep trying to get a contiguous block of
1420 the requested size, possibly discarding older traceframes to free
1421 up space. Since free space might come in one or two pieces,
1422 depending on whether discarded traceframes wrapped around at the
1423 high end of the buffer, we test both pieces after each
1427 /* First, if we have two free parts, try the upper one first. */
1428 if (tbctrl
->end_free
< tbctrl
->free
)
1430 if (tbctrl
->free
+ amt
<= trace_buffer_hi
)
1431 /* We have enough in the upper part. */
1435 /* Our high part of free space wasn't enough. Give up
1436 on it for now, set wraparound. We will recover the
1437 space later, if/when the wrapped-around traceframe is
1439 trace_debug ("Upper part too small, setting wraparound");
1440 tbctrl
->wrap
= tbctrl
->free
;
1441 tbctrl
->free
= trace_buffer_lo
;
1445 /* The normal case. */
1446 if (tbctrl
->free
+ amt
<= tbctrl
->end_free
)
1449 #ifdef IN_PROCESS_AGENT
1450 /* The IP Agent's buffer is always circular. It isn't used
1451 currently, but `circular_trace_buffer' could represent
1452 GDBserver's mode. If we didn't find space, ask GDBserver to
1455 flush_trace_buffer ();
1459 trace_debug ("gdbserver flushed buffer, retrying");
1463 /* GDBserver cancelled the tracing. Bail out as well. */
1466 /* If we're here, then neither part is big enough, and
1467 non-circular trace buffers are now full. */
1468 if (!circular_trace_buffer
)
1470 trace_debug ("Not enough space in the trace buffer");
1474 trace_debug ("Need more space in the trace buffer");
1476 /* If we have a circular buffer, we can try discarding the
1477 oldest traceframe and see if that helps. */
1478 oldest
= FIRST_TRACEFRAME ();
1479 if (oldest
->tpnum
== 0)
1481 /* Not good; we have no traceframes to free. Perhaps we're
1482 asking for a block that is larger than the buffer? In
1483 any case, give up. */
1484 trace_debug ("No traceframes to discard");
1488 /* We don't run this code in the in-process agent currently.
1489 E.g., we could leave the in-process agent in autonomous
1490 circular mode if we only have fast tracepoints. If we do
1491 that, then this bit becomes racy with GDBserver, which also
1492 writes to this counter. */
1493 --traceframe_write_count
;
1495 new_start
= (unsigned char *) NEXT_TRACEFRAME (oldest
);
1496 /* If we freed the traceframe that wrapped around, go back
1497 to the non-wrap case. */
1498 if (new_start
< tbctrl
->start
)
1500 trace_debug ("Discarding past the wraparound");
1501 tbctrl
->wrap
= trace_buffer_hi
;
1503 tbctrl
->start
= new_start
;
1504 tbctrl
->end_free
= tbctrl
->start
;
1506 trace_debug ("Discarded a traceframe\n"
1507 "Trace buffer [%d], start=%d free=%d "
1508 "endfree=%d wrap=%d hi=%d",
1510 (int) (tbctrl
->start
- trace_buffer_lo
),
1511 (int) (tbctrl
->free
- trace_buffer_lo
),
1512 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1513 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1514 (int) (trace_buffer_hi
- trace_buffer_lo
));
1516 /* Now go back around the loop. The discard might have resulted
1517 in either one or two pieces of free space, so we want to try
1518 both before freeing any more traceframes. */
1522 /* If we get here, we know we can provide the asked-for space. */
1524 rslt
= tbctrl
->free
;
1526 /* Adjust the request back down, now that we know we have space for
1527 the marker, but don't commit to AMT yet, we may still need to
1528 restart the operation if GDBserver touches the trace buffer
1529 (obviously only important in the in-process agent's version). */
1530 tbctrl
->free
+= (amt
- sizeof (struct traceframe
));
1532 /* Or not. If GDBserver changed the trace buffer behind our back,
1533 we get to restart a new allocation attempt. */
1535 #ifdef IN_PROCESS_AGENT
1536 /* Build the tentative token. */
1537 commit_count
= (((prev
& 0x0007ff00) + 0x100) & 0x0007ff00);
1538 commit
= (((prev
& 0x0007ff00) << 12)
1542 /* Try to commit it. */
1543 readout
= cmpxchg (&trace_buffer_ctrl_curr
, prev
, commit
);
1544 if (readout
!= prev
)
1546 trace_debug ("GDBserver has touched the trace buffer, restarting."
1547 " (prev=%08x, commit=%08x, readout=%08x)",
1548 prev
, commit
, readout
);
1552 /* Hold your horses here. Even if that change was committed,
1553 GDBserver could come in, and clobber it. We need to hold to be
1554 able to tell if GDBserver clobbers before or after we committed
1555 the change. Whenever GDBserver goes about touching the IPA
1556 buffer, it sets a breakpoint in this routine, so we have a sync
1558 about_to_request_buffer_space ();
1560 /* Check if the change has been effective, even if GDBserver stopped
1561 us at the breakpoint. */
1564 unsigned int refetch
;
1568 refetch
= trace_buffer_ctrl_curr
;
1570 if ((refetch
== commit
1571 || ((refetch
& 0x7ff00000) >> 12) == commit_count
))
1574 trace_debug ("change is effective: (prev=%08x, commit=%08x, "
1575 "readout=%08x, refetch=%08x)",
1576 prev
, commit
, readout
, refetch
);
1580 trace_debug ("GDBserver has touched the trace buffer, not effective."
1581 " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1582 prev
, commit
, readout
, refetch
);
1588 /* We have a new piece of the trace buffer. Hurray! */
1590 /* Add an EOB marker just past this allocation. */
1591 ((struct traceframe
*) tbctrl
->free
)->tpnum
= 0;
1592 ((struct traceframe
*) tbctrl
->free
)->data_size
= 0;
1594 /* Adjust the request back down, now that we know we have space for
1596 amt
-= sizeof (struct traceframe
);
1600 trace_debug ("Allocated %d bytes", (int) amt
);
1601 trace_debug ("Trace buffer [%d] start=%d free=%d "
1602 "endfree=%d wrap=%d hi=%d",
1604 (int) (tbctrl
->start
- trace_buffer_lo
),
1605 (int) (tbctrl
->free
- trace_buffer_lo
),
1606 (int) (tbctrl
->end_free
- trace_buffer_lo
),
1607 (int) (tbctrl
->wrap
- trace_buffer_lo
),
1608 (int) (trace_buffer_hi
- trace_buffer_lo
));
1614 #ifndef IN_PROCESS_AGENT
1616 /* Return the total free space. This is not necessarily the largest
1617 block we can allocate, because of the two-part case. */
1622 if (trace_buffer_free
<= trace_buffer_end_free
)
1623 return trace_buffer_end_free
- trace_buffer_free
;
1625 return ((trace_buffer_end_free
- trace_buffer_lo
)
1626 + (trace_buffer_hi
- trace_buffer_free
));
1629 /* An 'S' in continuation packets indicates remainder are for
1632 static int seen_step_action_flag
;
1634 /* Create a tracepoint (location) with given number and address. */
1636 static struct tracepoint
*
1637 add_tracepoint (int num
, CORE_ADDR addr
)
1639 struct tracepoint
*tpoint
;
1641 tpoint
= xmalloc (sizeof (struct tracepoint
));
1642 tpoint
->number
= num
;
1643 tpoint
->address
= addr
;
1644 tpoint
->numactions
= 0;
1645 tpoint
->actions
= NULL
;
1646 tpoint
->actions_str
= NULL
;
1647 tpoint
->cond
= NULL
;
1648 tpoint
->num_step_actions
= 0;
1649 tpoint
->step_actions
= NULL
;
1650 tpoint
->step_actions_str
= NULL
;
1651 /* Start all off as regular (slow) tracepoints. */
1652 tpoint
->type
= trap_tracepoint
;
1653 tpoint
->orig_size
= -1;
1654 tpoint
->source_strings
= NULL
;
1655 tpoint
->compiled_cond
= 0;
1656 tpoint
->handle
= NULL
;
1657 tpoint
->next
= NULL
;
1659 if (!last_tracepoint
)
1660 tracepoints
= tpoint
;
1662 last_tracepoint
->next
= tpoint
;
1663 last_tracepoint
= tpoint
;
1665 seen_step_action_flag
= 0;
1670 #ifndef IN_PROCESS_AGENT
1672 /* Return the tracepoint with the given number and address, or NULL. */
1674 static struct tracepoint
*
1675 find_tracepoint (int id
, CORE_ADDR addr
)
1677 struct tracepoint
*tpoint
;
1679 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
1680 if (tpoint
->number
== id
&& tpoint
->address
== addr
)
1686 /* There may be several tracepoints with the same number (because they
1687 are "locations", in GDB parlance); return the next one after the
1688 given tracepoint, or search from the beginning of the list if the
1689 first argument is NULL. */
1691 static struct tracepoint
*
1692 find_next_tracepoint_by_number (struct tracepoint
*prev_tp
, int num
)
1694 struct tracepoint
*tpoint
;
1697 tpoint
= prev_tp
->next
;
1699 tpoint
= tracepoints
;
1700 for (; tpoint
; tpoint
= tpoint
->next
)
1701 if (tpoint
->number
== num
)
1710 save_string (const char *str
, size_t len
)
1714 s
= xmalloc (len
+ 1);
1715 memcpy (s
, str
, len
);
1721 /* Append another action to perform when the tracepoint triggers. */
1724 add_tracepoint_action (struct tracepoint
*tpoint
, char *packet
)
1730 seen_step_action_flag
= 1;
1738 char *act_start
= act
;
1739 struct tracepoint_action
*action
= NULL
;
1745 struct collect_memory_action
*maction
;
1749 maction
= xmalloc (sizeof *maction
);
1750 maction
->base
.type
= *act
;
1751 action
= &maction
->base
;
1754 is_neg
= (*act
== '-');
1757 act
= unpack_varlen_hex (act
, &basereg
);
1759 act
= unpack_varlen_hex (act
, &maction
->addr
);
1761 act
= unpack_varlen_hex (act
, &maction
->len
);
1762 maction
->basereg
= (is_neg
1765 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
1766 pulongest (maction
->len
),
1767 paddress (maction
->addr
), maction
->basereg
);
1772 struct collect_registers_action
*raction
;
1774 raction
= xmalloc (sizeof *raction
);
1775 raction
->base
.type
= *act
;
1776 action
= &raction
->base
;
1778 trace_debug ("Want to collect registers");
1780 /* skip past hex digits of mask for now */
1781 while (isxdigit(*act
))
1787 struct collect_static_trace_data_action
*raction
;
1789 raction
= xmalloc (sizeof *raction
);
1790 raction
->base
.type
= *act
;
1791 action
= &raction
->base
;
1793 trace_debug ("Want to collect static trace data");
1798 trace_debug ("Unexpected step action, ignoring");
1803 struct eval_expr_action
*xaction
;
1805 xaction
= xmalloc (sizeof (*xaction
));
1806 xaction
->base
.type
= *act
;
1807 action
= &xaction
->base
;
1809 trace_debug ("Want to evaluate expression");
1810 xaction
->expr
= parse_agent_expr (&act
);
1814 trace_debug ("unknown trace action '%c', ignoring...", *act
);
1823 if (seen_step_action_flag
)
1825 tpoint
->num_step_actions
++;
1827 tpoint
->step_actions
1828 = xrealloc (tpoint
->step_actions
,
1829 (sizeof (*tpoint
->step_actions
)
1830 * tpoint
->num_step_actions
));
1831 tpoint
->step_actions_str
1832 = xrealloc (tpoint
->step_actions_str
,
1833 (sizeof (*tpoint
->step_actions_str
)
1834 * tpoint
->num_step_actions
));
1835 tpoint
->step_actions
[tpoint
->num_step_actions
- 1] = action
;
1836 tpoint
->step_actions_str
[tpoint
->num_step_actions
- 1]
1837 = save_string (act_start
, act
- act_start
);
1841 tpoint
->numactions
++;
1843 = xrealloc (tpoint
->actions
,
1844 sizeof (*tpoint
->actions
) * tpoint
->numactions
);
1846 = xrealloc (tpoint
->actions_str
,
1847 sizeof (*tpoint
->actions_str
) * tpoint
->numactions
);
1848 tpoint
->actions
[tpoint
->numactions
- 1] = action
;
1849 tpoint
->actions_str
[tpoint
->numactions
- 1]
1850 = save_string (act_start
, act
- act_start
);
1857 /* Find or create a trace state variable with the given number. */
1859 static struct trace_state_variable
*
1860 get_trace_state_variable (int num
)
1862 struct trace_state_variable
*tsv
;
1864 #ifdef IN_PROCESS_AGENT
1865 /* Search for an existing variable. */
1866 for (tsv
= alloced_trace_state_variables
; tsv
; tsv
= tsv
->next
)
1867 if (tsv
->number
== num
)
1871 /* Search for an existing variable. */
1872 for (tsv
= trace_state_variables
; tsv
; tsv
= tsv
->next
)
1873 if (tsv
->number
== num
)
1879 /* Find or create a trace state variable with the given number. */
1881 static struct trace_state_variable
*
1882 create_trace_state_variable (int num
, int gdb
)
1884 struct trace_state_variable
*tsv
;
1886 tsv
= get_trace_state_variable (num
);
1890 /* Create a new variable. */
1891 tsv
= xmalloc (sizeof (struct trace_state_variable
));
1893 tsv
->initial_value
= 0;
1897 #ifdef IN_PROCESS_AGENT
1900 tsv
->next
= alloced_trace_state_variables
;
1901 alloced_trace_state_variables
= tsv
;
1906 tsv
->next
= trace_state_variables
;
1907 trace_state_variables
= tsv
;
1912 IP_AGENT_EXPORT LONGEST
1913 get_trace_state_variable_value (int num
)
1915 struct trace_state_variable
*tsv
;
1917 tsv
= get_trace_state_variable (num
);
1921 trace_debug ("No trace state variable %d, skipping value get", num
);
1925 /* Call a getter function if we have one. While it's tempting to
1926 set up something to only call the getter once per tracepoint hit,
1927 it could run afoul of thread races. Better to let the getter
1928 handle it directly, if necessary to worry about it. */
1930 tsv
->value
= (tsv
->getter
) ();
1932 trace_debug ("get_trace_state_variable_value(%d) ==> %s",
1933 num
, plongest (tsv
->value
));
1938 IP_AGENT_EXPORT
void
1939 set_trace_state_variable_value (int num
, LONGEST val
)
1941 struct trace_state_variable
*tsv
;
1943 tsv
= get_trace_state_variable (num
);
1947 trace_debug ("No trace state variable %d, skipping value set", num
);
1955 set_trace_state_variable_name (int num
, const char *name
)
1957 struct trace_state_variable
*tsv
;
1959 tsv
= get_trace_state_variable (num
);
1963 trace_debug ("No trace state variable %d, skipping name set", num
);
1967 tsv
->name
= (char *) name
;
1971 set_trace_state_variable_getter (int num
, LONGEST (*getter
) (void))
1973 struct trace_state_variable
*tsv
;
1975 tsv
= get_trace_state_variable (num
);
1979 trace_debug ("No trace state variable %d, skipping getter set", num
);
1983 tsv
->getter
= getter
;
1986 /* Add a raw traceframe for the given tracepoint. */
1988 static struct traceframe
*
1989 add_traceframe (struct tracepoint
*tpoint
)
1991 struct traceframe
*tframe
;
1993 tframe
= trace_buffer_alloc (sizeof (struct traceframe
));
1998 tframe
->tpnum
= tpoint
->number
;
1999 tframe
->data_size
= 0;
2004 /* Add a block to the traceframe currently being worked on. */
2006 static unsigned char *
2007 add_traceframe_block (struct traceframe
*tframe
, int amt
)
2009 unsigned char *block
;
2014 block
= trace_buffer_alloc (amt
);
2019 tframe
->data_size
+= amt
;
2024 /* Flag that the current traceframe is finished. */
2027 finish_traceframe (struct traceframe
*tframe
)
2029 ++traceframe_write_count
;
2030 ++traceframes_created
;
2033 #ifndef IN_PROCESS_AGENT
2035 /* Given a traceframe number NUM, find the NUMth traceframe in the
2038 static struct traceframe
*
2039 find_traceframe (int num
)
2041 struct traceframe
*tframe
;
2044 for (tframe
= FIRST_TRACEFRAME ();
2046 tframe
= NEXT_TRACEFRAME (tframe
))
2057 get_traceframe_address (struct traceframe
*tframe
)
2060 struct tracepoint
*tpoint
;
2062 addr
= traceframe_get_pc (tframe
);
2067 /* Fallback strategy, will be incorrect for while-stepping frames
2068 and multi-location tracepoints. */
2069 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
2070 return tpoint
->address
;
2073 /* Search for the next traceframe whose address is inside or outside
2076 static struct traceframe
*
2077 find_next_traceframe_in_range (CORE_ADDR lo
, CORE_ADDR hi
, int inside_p
,
2080 struct traceframe
*tframe
;
2083 *tfnump
= current_traceframe
+ 1;
2084 tframe
= find_traceframe (*tfnump
);
2085 /* The search is not supposed to wrap around. */
2092 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2094 tfaddr
= get_traceframe_address (tframe
);
2096 ? (lo
<= tfaddr
&& tfaddr
<= hi
)
2097 : (lo
> tfaddr
|| tfaddr
> hi
))
2106 /* Search for the next traceframe recorded by the given tracepoint.
2107 Note that for multi-location tracepoints, this will find whatever
2108 location appears first. */
2110 static struct traceframe
*
2111 find_next_traceframe_by_tracepoint (int num
, int *tfnump
)
2113 struct traceframe
*tframe
;
2115 *tfnump
= current_traceframe
+ 1;
2116 tframe
= find_traceframe (*tfnump
);
2117 /* The search is not supposed to wrap around. */
2124 for (; tframe
->tpnum
!= 0; tframe
= NEXT_TRACEFRAME (tframe
))
2126 if (tframe
->tpnum
== num
)
2137 #ifndef IN_PROCESS_AGENT
2139 /* Clear all past trace state. */
2142 cmd_qtinit (char *packet
)
2144 struct trace_state_variable
*tsv
, *prev
, *next
;
2146 /* Make sure we don't try to read from a trace frame. */
2147 current_traceframe
= -1;
2149 trace_debug ("Initializing the trace");
2151 clear_installed_tracepoints ();
2152 clear_readonly_regions ();
2155 last_tracepoint
= NULL
;
2157 /* Clear out any leftover trace state variables. Ones with target
2158 defined getters should be kept however. */
2160 tsv
= trace_state_variables
;
2163 trace_debug ("Looking at var %d", tsv
->number
);
2164 if (tsv
->getter
== NULL
)
2170 trace_state_variables
= next
;
2171 trace_debug ("Deleting var %d", tsv
->number
);
2182 clear_trace_buffer ();
2183 clear_inferior_trace_buffer ();
2188 /* Unprobe the UST marker at ADDRESS. */
2191 unprobe_marker_at (CORE_ADDR address
)
2193 char cmd
[CMD_BUF_SIZE
];
2195 sprintf (cmd
, "unprobe_marker_at:%s", paddress (address
));
2196 run_inferior_command (cmd
);
2199 /* Restore the program to its pre-tracing state. This routine may be called
2200 in error situations, so it needs to be careful about only restoring
2201 from known-valid bits. */
2204 clear_installed_tracepoints (void)
2206 struct tracepoint
*tpoint
;
2207 struct tracepoint
*prev_stpoint
;
2210 cancel_breakpoints ();
2212 prev_stpoint
= NULL
;
2214 /* Restore any bytes overwritten by tracepoints. */
2215 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
2217 /* Catch the case where we might try to remove a tracepoint that
2218 was never actually installed. */
2219 if (tpoint
->handle
== NULL
)
2221 trace_debug ("Tracepoint %d at 0x%s was "
2222 "never installed, nothing to clear",
2223 tpoint
->number
, paddress (tpoint
->address
));
2227 switch (tpoint
->type
)
2229 case trap_tracepoint
:
2230 delete_breakpoint (tpoint
->handle
);
2232 case fast_tracepoint
:
2233 delete_fast_tracepoint_jump (tpoint
->handle
);
2235 case static_tracepoint
:
2236 if (prev_stpoint
!= NULL
2237 && prev_stpoint
->address
== tpoint
->address
)
2238 /* Nothing to do. We already unprobed a tracepoint set at
2239 this marker address (and there can only be one probe
2244 unprobe_marker_at (tpoint
->address
);
2245 prev_stpoint
= tpoint
;
2250 tpoint
->handle
= NULL
;
2256 /* Parse a packet that defines a tracepoint. */
2259 cmd_qtdp (char *own_buf
)
2265 struct tracepoint
*tpoint
;
2267 char *packet
= own_buf
;
2269 packet
+= strlen ("QTDP:");
2271 /* A hyphen at the beginning marks a packet specifying actions for a
2272 tracepoint already supplied. */
2279 packet
= unpack_varlen_hex (packet
, &num
);
2280 ++packet
; /* skip a colon */
2281 packet
= unpack_varlen_hex (packet
, &addr
);
2282 ++packet
; /* skip a colon */
2284 /* See if we already have this tracepoint. */
2285 tpoint
= find_tracepoint (num
, addr
);
2289 /* Duplicate tracepoints are never allowed. */
2292 trace_debug ("Tracepoint error: tracepoint %d"
2293 " at 0x%s already exists",
2294 (int) num
, paddress (addr
));
2295 write_enn (own_buf
);
2299 tpoint
= add_tracepoint (num
, addr
);
2301 tpoint
->enabled
= (*packet
== 'E');
2302 ++packet
; /* skip 'E' */
2303 ++packet
; /* skip a colon */
2304 packet
= unpack_varlen_hex (packet
, &count
);
2305 tpoint
->step_count
= count
;
2306 ++packet
; /* skip a colon */
2307 packet
= unpack_varlen_hex (packet
, &count
);
2308 tpoint
->pass_count
= count
;
2309 /* See if we have any of the additional optional fields. */
2310 while (*packet
== ':')
2315 tpoint
->type
= fast_tracepoint
;
2317 packet
= unpack_varlen_hex (packet
, &count
);
2318 tpoint
->orig_size
= count
;
2320 else if (*packet
== 'S')
2322 tpoint
->type
= static_tracepoint
;
2325 else if (*packet
== 'X')
2327 actparm
= (char *) packet
;
2328 tpoint
->cond
= parse_agent_expr (&actparm
);
2331 else if (*packet
== '-')
2333 else if (*packet
== '\0')
2336 trace_debug ("Unknown optional tracepoint field");
2339 trace_debug ("Also has actions\n");
2341 trace_debug ("Defined %stracepoint %d at 0x%s, "
2342 "enabled %d step %ld pass %ld",
2343 tpoint
->type
== fast_tracepoint
? "fast "
2345 tpoint
->number
, paddress (tpoint
->address
), tpoint
->enabled
,
2346 tpoint
->step_count
, tpoint
->pass_count
);
2349 add_tracepoint_action (tpoint
, packet
);
2352 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2353 (int) num
, paddress (addr
));
2354 write_enn (own_buf
);
2362 cmd_qtdpsrc (char *own_buf
)
2364 ULONGEST num
, addr
, start
, slen
;
2365 struct tracepoint
*tpoint
;
2366 char *packet
= own_buf
;
2367 char *saved
, *srctype
, *src
;
2369 struct source_string
*last
, *newlast
;
2371 packet
+= strlen ("QTDPsrc:");
2373 packet
= unpack_varlen_hex (packet
, &num
);
2374 ++packet
; /* skip a colon */
2375 packet
= unpack_varlen_hex (packet
, &addr
);
2376 ++packet
; /* skip a colon */
2378 /* See if we already have this tracepoint. */
2379 tpoint
= find_tracepoint (num
, addr
);
2383 trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2384 (int) num
, paddress (addr
));
2385 write_enn (own_buf
);
2390 packet
= strchr (packet
, ':');
2391 srctype
= xmalloc (packet
- saved
+ 1);
2392 memcpy (srctype
, saved
, packet
- saved
);
2393 srctype
[packet
- saved
] = '\0';
2395 packet
= unpack_varlen_hex (packet
, &start
);
2396 ++packet
; /* skip a colon */
2397 packet
= unpack_varlen_hex (packet
, &slen
);
2398 ++packet
; /* skip a colon */
2399 src
= xmalloc (slen
+ 1);
2400 nbytes
= unhexify (src
, packet
, strlen (packet
) / 2);
2403 newlast
= xmalloc (sizeof (struct source_string
));
2404 newlast
->type
= srctype
;
2406 newlast
->next
= NULL
;
2407 /* Always add a source string to the end of the list;
2408 this keeps sequences of actions/commands in the right
2410 if (tpoint
->source_strings
)
2412 for (last
= tpoint
->source_strings
; last
->next
; last
= last
->next
)
2414 last
->next
= newlast
;
2417 tpoint
->source_strings
= newlast
;
2423 cmd_qtdv (char *own_buf
)
2425 ULONGEST num
, val
, builtin
;
2428 struct trace_state_variable
*tsv
;
2429 char *packet
= own_buf
;
2431 packet
+= strlen ("QTDV:");
2433 packet
= unpack_varlen_hex (packet
, &num
);
2434 ++packet
; /* skip a colon */
2435 packet
= unpack_varlen_hex (packet
, &val
);
2436 ++packet
; /* skip a colon */
2437 packet
= unpack_varlen_hex (packet
, &builtin
);
2438 ++packet
; /* skip a colon */
2440 nbytes
= strlen (packet
) / 2;
2441 varname
= xmalloc (nbytes
+ 1);
2442 nbytes
= unhexify (varname
, packet
, nbytes
);
2443 varname
[nbytes
] = '\0';
2445 tsv
= create_trace_state_variable (num
, 1);
2446 tsv
->initial_value
= (LONGEST
) val
;
2447 tsv
->name
= varname
;
2449 set_trace_state_variable_value (num
, (LONGEST
) val
);
2455 cmd_qtenable_disable (char *own_buf
, int enable
)
2457 char *packet
= own_buf
;
2459 struct tracepoint
*tp
;
2461 packet
+= strlen (enable
? "QTEnable:" : "QTDisable:");
2462 packet
= unpack_varlen_hex (packet
, &num
);
2463 ++packet
; /* skip a colon */
2464 packet
= unpack_varlen_hex (packet
, &addr
);
2466 tp
= find_tracepoint (num
, addr
);
2470 if ((enable
&& tp
->enabled
) || (!enable
&& !tp
->enabled
))
2472 trace_debug ("Tracepoint %d at 0x%s is already %s",
2473 (int) num
, paddress (addr
),
2474 enable
? "enabled" : "disabled");
2479 trace_debug ("%s tracepoint %d at 0x%s",
2480 enable
? "Enabling" : "Disabling",
2481 (int) num
, paddress (addr
));
2483 tp
->enabled
= enable
;
2485 if (tp
->type
== fast_tracepoint
|| tp
->type
== static_tracepoint
)
2488 int offset
= offsetof (struct tracepoint
, enabled
);
2489 CORE_ADDR obj_addr
= tp
->obj_addr_on_target
+ offset
;
2491 ret
= prepare_to_access_memory ();
2494 trace_debug ("Failed to temporarily stop inferior threads");
2495 write_enn (own_buf
);
2499 ret
= write_inferior_integer (obj_addr
, enable
);
2500 done_accessing_memory ();
2504 trace_debug ("Cannot write enabled flag into "
2505 "inferior process memory");
2506 write_enn (own_buf
);
2515 trace_debug ("Tracepoint %d at 0x%s not found",
2516 (int) num
, paddress (addr
));
2517 write_enn (own_buf
);
2522 cmd_qtv (char *own_buf
)
2527 char *packet
= own_buf
;
2529 packet
+= strlen ("qTV:");
2530 unpack_varlen_hex (packet
, &num
);
2532 if (current_traceframe
>= 0)
2534 err
= traceframe_read_tsv ((int) num
, &val
);
2537 strcpy (own_buf
, "U");
2541 /* Only make tsv's be undefined before the first trace run. After a
2542 trace run is over, the user might want to see the last value of
2543 the tsv, and it might not be available in a traceframe. */
2544 else if (!tracing
&& strcmp (tracing_stop_reason
, "tnotrun") == 0)
2546 strcpy (own_buf
, "U");
2550 val
= get_trace_state_variable_value (num
);
2552 sprintf (own_buf
, "V%s", phex_nz (val
, 0));
2555 /* Clear out the list of readonly regions. */
2558 clear_readonly_regions (void)
2560 struct readonly_region
*roreg
;
2562 while (readonly_regions
)
2564 roreg
= readonly_regions
;
2565 readonly_regions
= readonly_regions
->next
;
2570 /* Parse the collection of address ranges whose contents GDB believes
2571 to be unchanging and so can be read directly from target memory
2572 even while looking at a traceframe. */
2575 cmd_qtro (char *own_buf
)
2577 ULONGEST start
, end
;
2578 struct readonly_region
*roreg
;
2579 char *packet
= own_buf
;
2581 trace_debug ("Want to mark readonly regions");
2583 clear_readonly_regions ();
2585 packet
+= strlen ("QTro");
2587 while (*packet
== ':')
2589 ++packet
; /* skip a colon */
2590 packet
= unpack_varlen_hex (packet
, &start
);
2591 ++packet
; /* skip a comma */
2592 packet
= unpack_varlen_hex (packet
, &end
);
2593 roreg
= xmalloc (sizeof (struct readonly_region
));
2594 roreg
->start
= start
;
2596 roreg
->next
= readonly_regions
;
2597 readonly_regions
= roreg
;
2598 trace_debug ("Added readonly region from 0x%s to 0x%s",
2599 paddress (roreg
->start
), paddress (roreg
->end
));
2605 /* Test to see if the given range is in our list of readonly ranges.
2606 We only test for being entirely within a range, GDB is not going to
2607 send a single memory packet that spans multiple regions. */
2610 in_readonly_region (CORE_ADDR addr
, ULONGEST length
)
2612 struct readonly_region
*roreg
;
2614 for (roreg
= readonly_regions
; roreg
; roreg
= roreg
->next
)
2615 if (roreg
->start
<= addr
&& (addr
+ length
- 1) <= roreg
->end
)
2621 /* The maximum size of a jump pad entry. */
2622 static const int max_jump_pad_size
= 0x100;
2624 static CORE_ADDR gdb_jump_pad_head
;
2626 /* Return the address of the next free jump space. */
2629 get_jump_space_head (void)
2631 if (gdb_jump_pad_head
== 0)
2633 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
2634 &gdb_jump_pad_head
))
2635 fatal ("error extracting jump_pad_buffer");
2638 return gdb_jump_pad_head
;
2641 /* Reserve USED bytes from the jump space. */
2644 claim_jump_space (ULONGEST used
)
2646 trace_debug ("claim_jump_space reserves %s bytes at %s",
2647 pulongest (used
), paddress (gdb_jump_pad_head
));
2648 gdb_jump_pad_head
+= used
;
2651 /* Sort tracepoints by PC, using a bubble sort. */
2654 sort_tracepoints (void)
2656 struct tracepoint
*lst
, *tmp
, *prev
= NULL
;
2659 if (tracepoints
== NULL
)
2663 for (tmp
= tracepoints
; tmp
->next
; tmp
= tmp
->next
)
2666 for (i
= 0; i
< n
- 1; i
++)
2667 for (j
= 0, lst
= tracepoints
;
2668 lst
&& lst
->next
&& (j
<= n
- 1 - i
);
2671 /* If we're at beginning, the start node is the prev
2676 /* Compare neighbors. */
2677 if (lst
->next
->address
< lst
->address
)
2679 struct tracepoint
*p
;
2682 tmp
= (lst
->next
? lst
->next
->next
: NULL
);
2684 if (j
== 0 && prev
== tracepoints
)
2685 tracepoints
= lst
->next
;
2688 prev
->next
= lst
->next
;
2689 lst
->next
->next
= lst
;
2696 /* Keep track of the previous node. We need it if we need
2704 /* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
2705 the command fails, or 0 otherwise. If the command ran
2706 successfully, but probing the marker failed, ERROUT will be filled
2707 with the error to reply to GDB, and -1 is also returned. This
2708 allows directly passing IPA errors to GDB. */
2711 probe_marker_at (CORE_ADDR address
, char *errout
)
2713 char cmd
[CMD_BUF_SIZE
];
2716 sprintf (cmd
, "probe_marker_at:%s", paddress (address
));
2717 err
= run_inferior_command (cmd
);
2723 strcpy (errout
, cmd
);
2731 #define MAX_JUMP_SIZE 20
2734 cmd_qtstart (char *packet
)
2736 struct tracepoint
*tpoint
, *prev_ftpoint
, *prev_stpoint
;
2737 int slow_tracepoint_count
, fast_count
;
2738 CORE_ADDR jump_entry
;
2740 /* The jump to the jump pad of the last fast tracepoint
2742 unsigned char fjump
[MAX_JUMP_SIZE
];
2743 ULONGEST fjump_size
;
2745 trace_debug ("Starting the trace");
2747 slow_tracepoint_count
= fast_count
= 0;
2749 /* Sort tracepoints by ascending address. This makes installing
2750 fast tracepoints at the same address easier to handle. */
2751 sort_tracepoints ();
2753 /* Pause all threads temporarily while we patch tracepoints. */
2756 /* Get threads out of jump pads. Safe to do here, since this is a
2757 top level command. And, required to do here, since we're
2758 deleting/rewriting jump pads. */
2760 stabilize_threads ();
2762 /* Freeze threads. */
2765 /* Sync the fast tracepoints list in the inferior ftlib. */
2766 if (in_process_agent_loaded ())
2768 download_tracepoints ();
2769 download_trace_state_variables ();
2772 /* No previous fast tpoint yet. */
2773 prev_ftpoint
= NULL
;
2775 /* No previous static tpoint yet. */
2776 prev_stpoint
= NULL
;
2780 /* Install tracepoints. */
2781 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
2783 /* Ensure all the hit counts start at zero. */
2784 tpoint
->hit_count
= 0;
2786 if (tpoint
->type
== trap_tracepoint
)
2788 ++slow_tracepoint_count
;
2790 /* Tracepoints are installed as memory breakpoints. Just go
2791 ahead and install the trap. The breakpoints module
2792 handles duplicated breakpoints, and the memory read
2793 routine handles un-patching traps from memory reads. */
2794 tpoint
->handle
= set_breakpoint_at (tpoint
->address
,
2795 tracepoint_handler
);
2797 else if (tpoint
->type
== fast_tracepoint
)
2801 if (maybe_write_ipa_not_loaded (packet
))
2803 trace_debug ("Requested a fast tracepoint, but fast "
2804 "tracepoints aren't supported.");
2808 if (prev_ftpoint
!= NULL
&& prev_ftpoint
->address
== tpoint
->address
)
2810 tpoint
->handle
= set_fast_tracepoint_jump (tpoint
->address
,
2813 tpoint
->jump_pad
= prev_ftpoint
->jump_pad
;
2814 tpoint
->jump_pad_end
= prev_ftpoint
->jump_pad_end
;
2815 tpoint
->adjusted_insn_addr
= prev_ftpoint
->adjusted_insn_addr
;
2816 tpoint
->adjusted_insn_addr_end
2817 = prev_ftpoint
->adjusted_insn_addr_end
;
2824 prev_ftpoint
= NULL
;
2826 jentry
= jump_entry
= get_jump_space_head ();
2828 /* Install the jump pad. */
2829 err
= install_fast_tracepoint_jump_pad
2830 (tpoint
->obj_addr_on_target
,
2832 ipa_sym_addrs
.addr_gdb_collect
,
2833 ipa_sym_addrs
.addr_collecting
,
2837 &tpoint
->adjusted_insn_addr
,
2838 &tpoint
->adjusted_insn_addr_end
);
2842 tpoint
->handle
= set_fast_tracepoint_jump (tpoint
->address
,
2845 if (tpoint
->handle
!= NULL
)
2847 tpoint
->jump_pad
= jump_entry
;
2848 tpoint
->jump_pad_end
= jentry
;
2850 /* Pad to 8-byte alignment. */
2851 jentry
= ((jentry
+ 7) & ~0x7);
2852 claim_jump_space (jentry
- jump_entry
);
2854 /* So that we can handle multiple fast tracepoints
2855 at the same address easily. */
2856 prev_ftpoint
= tpoint
;
2860 else if (tpoint
->type
== static_tracepoint
)
2862 if (maybe_write_ipa_ust_not_loaded (packet
))
2864 trace_debug ("Requested a static tracepoint, but static "
2865 "tracepoints are not supported.");
2869 /* Can only probe a given marker once. */
2870 if (prev_stpoint
!= NULL
&& prev_stpoint
->address
== tpoint
->address
)
2872 tpoint
->handle
= (void *) -1;
2876 if (probe_marker_at (tpoint
->address
, packet
) == 0)
2878 tpoint
->handle
= (void *) -1;
2880 /* So that we can handle multiple static tracepoints
2881 at the same address easily. */
2882 prev_stpoint
= tpoint
;
2887 /* Any failure in the inner loop is sufficient cause to give
2889 if (tpoint
->handle
== NULL
)
2893 /* Any error in tracepoint insertion is unacceptable; better to
2894 address the problem now, than end up with a useless or misleading
2898 clear_installed_tracepoints ();
2899 if (*packet
== '\0')
2905 stopping_tracepoint
= NULL
;
2906 trace_buffer_is_full
= 0;
2907 expr_eval_result
= expr_eval_no_error
;
2908 error_tracepoint
= NULL
;
2910 /* Tracing is now active, hits will now start being logged. */
2913 if (in_process_agent_loaded ())
2915 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 1))
2916 fatal ("Error setting tracing variable in lib");
2918 if (write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
2920 fatal ("Error clearing stopping_tracepoint variable in lib");
2922 if (write_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
, 0))
2923 fatal ("Error clearing trace_buffer_is_full variable in lib");
2925 stop_tracing_bkpt
= set_breakpoint_at (ipa_sym_addrs
.addr_stop_tracing
,
2926 stop_tracing_handler
);
2927 if (stop_tracing_bkpt
== NULL
)
2928 error ("Error setting stop_tracing breakpoint");
2930 flush_trace_buffer_bkpt
2931 = set_breakpoint_at (ipa_sym_addrs
.addr_flush_trace_buffer
,
2932 flush_trace_buffer_handler
);
2933 if (flush_trace_buffer_bkpt
== NULL
)
2934 error ("Error setting flush_trace_buffer breakpoint");
2942 /* End a tracing run, filling in a stop reason to report back to GDB,
2943 and removing the tracepoints from the code. */
2950 trace_debug ("Tracing is already off, ignoring");
2954 trace_debug ("Stopping the trace");
2956 /* Pause all threads before removing fast jumps from memory,
2957 breakpoints, and touching IPA state variables (inferior memory).
2958 Some thread may hit the internal tracing breakpoints, or be
2959 collecting this moment, but that's ok, we don't release the
2960 tpoint object's memory or the jump pads here (we only do that
2961 when we're sure we can move all threads out of the jump pads).
2962 We can't now, since we may be getting here due to the inferior
2963 agent calling us. */
2965 /* Since we're removing breakpoints, cancel breakpoint hits,
2966 possibly related to the breakpoints we're about to delete. */
2967 cancel_breakpoints ();
2969 /* Stop logging. Tracepoints can still be hit, but they will not be
2972 if (in_process_agent_loaded ())
2974 if (write_inferior_integer (ipa_sym_addrs
.addr_tracing
, 0))
2975 fatal ("Error clearing tracing variable in lib");
2978 tracing_stop_reason
= "t???";
2979 tracing_stop_tpnum
= 0;
2980 if (stopping_tracepoint
)
2982 trace_debug ("Stopping the trace because "
2983 "tracepoint %d was hit %ld times",
2984 stopping_tracepoint
->number
,
2985 stopping_tracepoint
->pass_count
);
2986 tracing_stop_reason
= "tpasscount";
2987 tracing_stop_tpnum
= stopping_tracepoint
->number
;
2989 else if (trace_buffer_is_full
)
2991 trace_debug ("Stopping the trace because the trace buffer is full");
2992 tracing_stop_reason
= "tfull";
2994 else if (expr_eval_result
!= expr_eval_no_error
)
2996 trace_debug ("Stopping the trace because of an expression eval error");
2997 tracing_stop_reason
= eval_result_names
[expr_eval_result
];
2998 tracing_stop_tpnum
= error_tracepoint
->number
;
3000 #ifndef IN_PROCESS_AGENT
3001 else if (!gdb_connected ())
3003 trace_debug ("Stopping the trace because GDB disconnected");
3004 tracing_stop_reason
= "tdisconnected";
3009 trace_debug ("Stopping the trace because of a tstop command");
3010 tracing_stop_reason
= "tstop";
3013 stopping_tracepoint
= NULL
;
3014 error_tracepoint
= NULL
;
3016 /* Clear out the tracepoints. */
3017 clear_installed_tracepoints ();
3019 if (in_process_agent_loaded ())
3021 /* Pull in fast tracepoint trace frames from the inferior lib
3022 buffer into our buffer, even if our buffer is already full,
3023 because we want to present the full number of created frames
3024 in addition to what fit in the trace buffer. */
3025 upload_fast_traceframes ();
3028 if (stop_tracing_bkpt
!= NULL
)
3030 delete_breakpoint (stop_tracing_bkpt
);
3031 stop_tracing_bkpt
= NULL
;
3034 if (flush_trace_buffer_bkpt
!= NULL
)
3036 delete_breakpoint (flush_trace_buffer_bkpt
);
3037 flush_trace_buffer_bkpt
= NULL
;
3044 stop_tracing_handler (CORE_ADDR addr
)
3046 trace_debug ("lib hit stop_tracing");
3048 /* Don't actually handle it here. When we stop tracing we remove
3049 breakpoints from the inferior, and that is not allowed in a
3050 breakpoint handler (as the caller is walking the breakpoint
3056 flush_trace_buffer_handler (CORE_ADDR addr
)
3058 trace_debug ("lib hit flush_trace_buffer");
3063 cmd_qtstop (char *packet
)
3070 cmd_qtdisconnected (char *own_buf
)
3073 char *packet
= own_buf
;
3075 packet
+= strlen ("QTDisconnected:");
3077 unpack_varlen_hex (packet
, &setting
);
3081 disconnected_tracing
= setting
;
3085 cmd_qtframe (char *own_buf
)
3087 ULONGEST frame
, pc
, lo
, hi
, num
;
3089 struct traceframe
*tframe
;
3090 char *packet
= own_buf
;
3092 packet
+= strlen ("QTFrame:");
3094 if (strncmp (packet
, "pc:", strlen ("pc:")) == 0)
3096 packet
+= strlen ("pc:");
3097 unpack_varlen_hex (packet
, &pc
);
3098 trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc
));
3099 tframe
= find_next_traceframe_in_range (pc
, pc
, 1, &tfnum
);
3101 else if (strncmp (packet
, "range:", strlen ("range:")) == 0)
3103 packet
+= strlen ("range:");
3104 packet
= unpack_varlen_hex (packet
, &lo
);
3106 unpack_varlen_hex (packet
, &hi
);
3107 trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s",
3108 paddress (lo
), paddress (hi
));
3109 tframe
= find_next_traceframe_in_range (lo
, hi
, 1, &tfnum
);
3111 else if (strncmp (packet
, "outside:", strlen ("outside:")) == 0)
3113 packet
+= strlen ("outside:");
3114 packet
= unpack_varlen_hex (packet
, &lo
);
3116 unpack_varlen_hex (packet
, &hi
);
3117 trace_debug ("Want to find next traceframe "
3118 "outside the range 0x%s to 0x%s",
3119 paddress (lo
), paddress (hi
));
3120 tframe
= find_next_traceframe_in_range (lo
, hi
, 0, &tfnum
);
3122 else if (strncmp (packet
, "tdp:", strlen ("tdp:")) == 0)
3124 packet
+= strlen ("tdp:");
3125 unpack_varlen_hex (packet
, &num
);
3127 trace_debug ("Want to find next traceframe for tracepoint %d", tpnum
);
3128 tframe
= find_next_traceframe_by_tracepoint (tpnum
, &tfnum
);
3132 unpack_varlen_hex (packet
, &frame
);
3133 tfnum
= (int) frame
;
3136 trace_debug ("Want to stop looking at traceframes");
3137 current_traceframe
= -1;
3141 trace_debug ("Want to look at traceframe %d", tfnum
);
3142 tframe
= find_traceframe (tfnum
);
3147 current_traceframe
= tfnum
;
3148 sprintf (own_buf
, "F%xT%x", tfnum
, tframe
->tpnum
);
3151 sprintf (own_buf
, "F-1");
3155 cmd_qtstatus (char *packet
)
3157 char *stop_reason_rsp
= NULL
;
3159 trace_debug ("Returning trace status as %d, stop reason %s",
3160 tracing
, tracing_stop_reason
);
3162 if (in_process_agent_loaded ())
3166 upload_fast_traceframes ();
3171 stop_reason_rsp
= (char *) tracing_stop_reason
;
3173 /* The user visible error string in terror needs to be hex encoded.
3174 We leave it as plain string in `tracepoint_stop_reason' to ease
3176 if (strncmp (stop_reason_rsp
, "terror:", strlen ("terror:")) == 0)
3178 const char *result_name
;
3182 result_name
= stop_reason_rsp
+ strlen ("terror:");
3183 hexstr_len
= strlen (result_name
) * 2;
3184 p
= stop_reason_rsp
= alloca (strlen ("terror:") + hexstr_len
+ 1);
3185 strcpy (p
, "terror:");
3187 convert_int_to_ascii ((gdb_byte
*) result_name
, p
, strlen (result_name
));
3193 "tframes:%x;tcreated:%x;"
3194 "tfree:%x;tsize:%s;"
3198 stop_reason_rsp
, tracing_stop_tpnum
,
3199 traceframe_count
, traceframes_created
,
3200 free_space (), phex_nz (trace_buffer_hi
- trace_buffer_lo
, 0),
3201 circular_trace_buffer
,
3202 disconnected_tracing
);
3205 /* State variables to help return all the tracepoint bits. */
3206 static struct tracepoint
*cur_tpoint
;
3207 static int cur_action
;
3208 static int cur_step_action
;
3209 static struct source_string
*cur_source_string
;
3210 static struct trace_state_variable
*cur_tsv
;
3212 /* Compose a response that is an imitation of the syntax by which the
3213 tracepoint was originally downloaded. */
3216 response_tracepoint (char *packet
, struct tracepoint
*tpoint
)
3220 sprintf (packet
, "T%x:%s:%c:%lx:%lx", tpoint
->number
,
3221 paddress (tpoint
->address
),
3222 (tpoint
->enabled
? 'E' : 'D'), tpoint
->step_count
,
3223 tpoint
->pass_count
);
3224 if (tpoint
->type
== fast_tracepoint
)
3225 sprintf (packet
+ strlen (packet
), ":F%x", tpoint
->orig_size
);
3226 else if (tpoint
->type
== static_tracepoint
)
3227 sprintf (packet
+ strlen (packet
), ":S");
3231 buf
= unparse_agent_expr (tpoint
->cond
);
3232 sprintf (packet
+ strlen (packet
), ":X%x,%s",
3233 tpoint
->cond
->length
, buf
);
3238 /* Compose a response that is an imitation of the syntax by which the
3239 tracepoint action was originally downloaded (with the difference
3240 that due to the way we store the actions, this will output a packet
3241 per action, while GDB could have combined more than one action
3245 response_action (char *packet
, struct tracepoint
*tpoint
,
3246 char *taction
, int step
)
3248 sprintf (packet
, "%c%x:%s:%s",
3249 (step
? 'S' : 'A'), tpoint
->number
, paddress (tpoint
->address
),
3253 /* Compose a response that is an imitation of the syntax by which the
3254 tracepoint source piece was originally downloaded. */
3257 response_source (char *packet
,
3258 struct tracepoint
*tpoint
, struct source_string
*src
)
3263 len
= strlen (src
->str
);
3264 buf
= alloca (len
* 2 + 1);
3265 convert_int_to_ascii ((gdb_byte
*) src
->str
, buf
, len
);
3267 sprintf (packet
, "Z%x:%s:%s:%x:%x:%s",
3268 tpoint
->number
, paddress (tpoint
->address
),
3269 src
->type
, 0, len
, buf
);
3272 /* Return the first piece of tracepoint definition, and initialize the
3273 state machine that will iterate through all the tracepoint
3277 cmd_qtfp (char *packet
)
3279 trace_debug ("Returning first tracepoint definition piece");
3281 cur_tpoint
= tracepoints
;
3282 cur_action
= cur_step_action
= -1;
3283 cur_source_string
= NULL
;
3286 response_tracepoint (packet
, cur_tpoint
);
3288 strcpy (packet
, "l");
3291 /* Return additional pieces of tracepoint definition. Each action and
3292 stepping action must go into its own packet, because of packet size
3293 limits, and so we use state variables to deliver one piece at a
3297 cmd_qtsp (char *packet
)
3299 trace_debug ("Returning subsequent tracepoint definition piece");
3303 /* This case would normally never occur, but be prepared for
3305 strcpy (packet
, "l");
3307 else if (cur_action
< cur_tpoint
->numactions
- 1)
3310 response_action (packet
, cur_tpoint
,
3311 cur_tpoint
->actions_str
[cur_action
], 0);
3313 else if (cur_step_action
< cur_tpoint
->num_step_actions
- 1)
3316 response_action (packet
, cur_tpoint
,
3317 cur_tpoint
->step_actions_str
[cur_step_action
], 1);
3319 else if ((cur_source_string
3320 ? cur_source_string
->next
3321 : cur_tpoint
->source_strings
))
3323 if (cur_source_string
)
3324 cur_source_string
= cur_source_string
->next
;
3326 cur_source_string
= cur_tpoint
->source_strings
;
3327 response_source (packet
, cur_tpoint
, cur_source_string
);
3331 cur_tpoint
= cur_tpoint
->next
;
3332 cur_action
= cur_step_action
= -1;
3333 cur_source_string
= NULL
;
3335 response_tracepoint (packet
, cur_tpoint
);
3337 strcpy (packet
, "l");
3341 /* Compose a response that is an imitation of the syntax by which the
3342 trace state variable was originally downloaded. */
3345 response_tsv (char *packet
, struct trace_state_variable
*tsv
)
3347 char *buf
= (char *) "";
3352 namelen
= strlen (tsv
->name
);
3353 buf
= alloca (namelen
* 2 + 1);
3354 convert_int_to_ascii ((gdb_byte
*) tsv
->name
, buf
, namelen
);
3357 sprintf (packet
, "%x:%s:%x:%s", tsv
->number
, phex_nz (tsv
->initial_value
, 0),
3358 tsv
->getter
? 1 : 0, buf
);
3361 /* Return the first trace state variable definition, and initialize
3362 the state machine that will iterate through all the tsv bits. */
3365 cmd_qtfv (char *packet
)
3367 trace_debug ("Returning first trace state variable definition");
3369 cur_tsv
= trace_state_variables
;
3372 response_tsv (packet
, cur_tsv
);
3374 strcpy (packet
, "l");
3377 /* Return additional trace state variable definitions. */
3380 cmd_qtsv (char *packet
)
3382 trace_debug ("Returning first trace state variable definition");
3386 /* This case would normally never occur, but be prepared for
3388 strcpy (packet
, "l");
3392 cur_tsv
= cur_tsv
->next
;
3394 response_tsv (packet
, cur_tsv
);
3396 strcpy (packet
, "l");
3399 strcpy (packet
, "l");
3402 /* Return the first static tracepoint marker, and initialize the state
3403 machine that will iterate through all the static tracepoints
3407 cmd_qtfstm (char *packet
)
3409 if (!maybe_write_ipa_ust_not_loaded (packet
))
3410 run_inferior_command (packet
);
3413 /* Return additional static tracepoints markers. */
3416 cmd_qtsstm (char *packet
)
3418 if (!maybe_write_ipa_ust_not_loaded (packet
))
3419 run_inferior_command (packet
);
3422 /* Return the definition of the static tracepoint at a given address.
3423 Result packet is the same as qTsST's. */
3426 cmd_qtstmat (char *packet
)
3428 if (!maybe_write_ipa_ust_not_loaded (packet
))
3429 run_inferior_command (packet
);
3432 /* Respond to qTBuffer packet with a block of raw data from the trace
3433 buffer. GDB may ask for a lot, but we are allowed to reply with
3434 only as much as will fit within packet limits or whatever. */
3437 cmd_qtbuffer (char *own_buf
)
3439 ULONGEST offset
, num
, tot
;
3441 char *packet
= own_buf
;
3443 packet
+= strlen ("qTBuffer:");
3445 packet
= unpack_varlen_hex (packet
, &offset
);
3446 ++packet
; /* skip a comma */
3447 unpack_varlen_hex (packet
, &num
);
3449 trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s",
3450 (int) num
, pulongest (offset
));
3452 tot
= (trace_buffer_hi
- trace_buffer_lo
) - free_space ();
3454 /* If we're right at the end, reply specially that we're done. */
3457 strcpy (own_buf
, "l");
3461 /* Object to any other out-of-bounds request. */
3464 write_enn (own_buf
);
3468 /* Compute the pointer corresponding to the given offset, accounting
3470 tbp
= trace_buffer_start
+ offset
;
3471 if (tbp
>= trace_buffer_wrap
)
3472 tbp
-= (trace_buffer_wrap
- trace_buffer_lo
);
3474 /* Trim to the remaining bytes if we're close to the end. */
3475 if (num
> tot
- offset
)
3478 /* Trim to available packet size. */
3479 if (num
>= (PBUFSIZ
- 16) / 2 )
3480 num
= (PBUFSIZ
- 16) / 2;
3482 convert_int_to_ascii (tbp
, own_buf
, num
);
3483 own_buf
[num
] = '\0';
3487 cmd_bigqtbuffer (char *own_buf
)
3490 char *packet
= own_buf
;
3492 packet
+= strlen ("QTBuffer:");
3494 if (strncmp ("circular:", packet
, strlen ("circular:")) == 0)
3496 packet
+= strlen ("circular:");
3497 unpack_varlen_hex (packet
, &val
);
3498 circular_trace_buffer
= val
;
3499 trace_debug ("Trace buffer is now %s",
3500 circular_trace_buffer
? "circular" : "linear");
3504 write_enn (own_buf
);
3508 handle_tracepoint_general_set (char *packet
)
3510 if (strcmp ("QTinit", packet
) == 0)
3512 cmd_qtinit (packet
);
3515 else if (strncmp ("QTDP:", packet
, strlen ("QTDP:")) == 0)
3520 else if (strncmp ("QTDPsrc:", packet
, strlen ("QTDPsrc:")) == 0)
3522 cmd_qtdpsrc (packet
);
3525 else if (strncmp ("QTEnable:", packet
, strlen ("QTEnable:")) == 0)
3527 cmd_qtenable_disable (packet
, 1);
3530 else if (strncmp ("QTDisable:", packet
, strlen ("QTDisable:")) == 0)
3532 cmd_qtenable_disable (packet
, 0);
3535 else if (strncmp ("QTDV:", packet
, strlen ("QTDV:")) == 0)
3540 else if (strncmp ("QTro:", packet
, strlen ("QTro:")) == 0)
3545 else if (strcmp ("QTStart", packet
) == 0)
3547 cmd_qtstart (packet
);
3550 else if (strcmp ("QTStop", packet
) == 0)
3552 cmd_qtstop (packet
);
3555 else if (strncmp ("QTDisconnected:", packet
,
3556 strlen ("QTDisconnected:")) == 0)
3558 cmd_qtdisconnected (packet
);
3561 else if (strncmp ("QTFrame:", packet
, strlen ("QTFrame:")) == 0)
3563 cmd_qtframe (packet
);
3566 else if (strncmp ("QTBuffer:", packet
, strlen ("QTBuffer:")) == 0)
3568 cmd_bigqtbuffer (packet
);
3576 handle_tracepoint_query (char *packet
)
3578 if (strcmp ("qTStatus", packet
) == 0)
3580 cmd_qtstatus (packet
);
3583 else if (strcmp ("qTfP", packet
) == 0)
3588 else if (strcmp ("qTsP", packet
) == 0)
3593 else if (strcmp ("qTfV", packet
) == 0)
3598 else if (strcmp ("qTsV", packet
) == 0)
3603 else if (strncmp ("qTV:", packet
, strlen ("qTV:")) == 0)
3608 else if (strncmp ("qTBuffer:", packet
, strlen ("qTBuffer:")) == 0)
3610 cmd_qtbuffer (packet
);
3613 else if (strcmp ("qTfSTM", packet
) == 0)
3615 cmd_qtfstm (packet
);
3618 else if (strcmp ("qTsSTM", packet
) == 0)
3620 cmd_qtsstm (packet
);
3623 else if (strncmp ("qTSTMat:", packet
, strlen ("qTSTMat:")) == 0)
3625 cmd_qtstmat (packet
);
3633 #ifndef IN_PROCESS_AGENT
3635 /* Call this when thread TINFO has hit the tracepoint defined by
3636 TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping
3637 action. This adds a while-stepping collecting state item to the
3638 threads' collecting state list, so that we can keep track of
3639 multiple simultaneous while-stepping actions being collected by the
3640 same thread. This can happen in cases like:
3642 ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs
3644 ff0003 INSN3 <-- TP2, collect $regs
3645 ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs
3648 Notice that when instruction INSN5 is reached, the while-stepping
3649 actions of both TP1 and TP3 are still being collected, and that TP2
3650 had been collected meanwhile. The whole range of ff0001-ff0005
3651 should be single-stepped, due to at least TP1's while-stepping
3652 action covering the whole range. */
3655 add_while_stepping_state (struct thread_info
*tinfo
,
3656 int tp_number
, CORE_ADDR tp_address
)
3658 struct wstep_state
*wstep
;
3660 wstep
= xmalloc (sizeof (*wstep
));
3661 wstep
->next
= tinfo
->while_stepping
;
3663 wstep
->tp_number
= tp_number
;
3664 wstep
->tp_address
= tp_address
;
3665 wstep
->current_step
= 0;
3667 tinfo
->while_stepping
= wstep
;
3670 /* Release the while-stepping collecting state WSTEP. */
3673 release_while_stepping_state (struct wstep_state
*wstep
)
3678 /* Release all while-stepping collecting states currently associated
3679 with thread TINFO. */
3682 release_while_stepping_state_list (struct thread_info
*tinfo
)
3684 struct wstep_state
*head
;
3686 while (tinfo
->while_stepping
)
3688 head
= tinfo
->while_stepping
;
3689 tinfo
->while_stepping
= head
->next
;
3690 release_while_stepping_state (head
);
3694 /* If TINFO was handling a 'while-stepping' action, the step has
3695 finished, so collect any step data needed, and check if any more
3696 steps are required. Return true if the thread was indeed
3697 collecting tracepoint data, false otherwise. */
3700 tracepoint_finished_step (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
3702 struct tracepoint
*tpoint
;
3703 struct wstep_state
*wstep
;
3704 struct wstep_state
**wstep_link
;
3705 struct trap_tracepoint_ctx ctx
;
3707 /* Pull in fast tracepoint trace frames from the inferior lib buffer into
3709 if (in_process_agent_loaded ())
3710 upload_fast_traceframes ();
3712 /* Check if we were indeed collecting data for one of more
3713 tracepoints with a 'while-stepping' count. */
3714 if (tinfo
->while_stepping
== NULL
)
3719 /* We're not even tracing anymore. Stop this thread from
3721 release_while_stepping_state_list (tinfo
);
3723 /* The thread had stopped due to a single-step request indeed
3724 explained by a tracepoint. */
3728 wstep
= tinfo
->while_stepping
;
3729 wstep_link
= &tinfo
->while_stepping
;
3731 trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
3732 target_pid_to_str (tinfo
->entry
.id
),
3733 wstep
->tp_number
, paddress (wstep
->tp_address
));
3735 ctx
.base
.type
= trap_tracepoint
;
3736 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
3738 while (wstep
!= NULL
)
3740 tpoint
= find_tracepoint (wstep
->tp_number
, wstep
->tp_address
);
3743 trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
3744 wstep
->tp_number
, paddress (wstep
->tp_address
),
3745 target_pid_to_str (tinfo
->entry
.id
));
3748 *wstep_link
= wstep
->next
;
3749 release_while_stepping_state (wstep
);
3750 wstep
= *wstep_link
;
3754 /* We've just finished one step. */
3755 ++wstep
->current_step
;
3758 collect_data_at_step ((struct tracepoint_hit_ctx
*) &ctx
,
3759 stop_pc
, tpoint
, wstep
->current_step
);
3761 if (wstep
->current_step
>= tpoint
->step_count
)
3763 /* The requested numbers of steps have occurred. */
3764 trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
3765 target_pid_to_str (tinfo
->entry
.id
),
3766 wstep
->tp_number
, paddress (wstep
->tp_address
));
3768 /* Unlink the wstep. */
3769 *wstep_link
= wstep
->next
;
3770 release_while_stepping_state (wstep
);
3771 wstep
= *wstep_link
;
3773 /* Only check the hit count now, which ensure that we do all
3774 our stepping before stopping the run. */
3775 if (tpoint
->pass_count
> 0
3776 && tpoint
->hit_count
>= tpoint
->pass_count
3777 && stopping_tracepoint
== NULL
)
3778 stopping_tracepoint
= tpoint
;
3782 /* Keep single-stepping until the requested numbers of steps
3784 wstep_link
= &wstep
->next
;
3785 wstep
= *wstep_link
;
3788 if (stopping_tracepoint
3789 || trace_buffer_is_full
3790 || expr_eval_result
!= expr_eval_no_error
)
3800 /* Handle any internal tracing control breakpoint hits. That means,
3801 pull traceframes from the IPA to our buffer, and syncing both
3802 tracing agents when the IPA's tracing stops for some reason. */
3805 handle_tracepoint_bkpts (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
3807 /* Pull in fast tracepoint trace frames from the inferior in-process
3808 agent's buffer into our buffer. */
3810 if (!in_process_agent_loaded ())
3813 upload_fast_traceframes ();
3815 /* Check if the in-process agent had decided we should stop
3817 if (stop_pc
== ipa_sym_addrs
.addr_stop_tracing
)
3819 int ipa_trace_buffer_is_full
;
3820 CORE_ADDR ipa_stopping_tracepoint
;
3821 int ipa_expr_eval_result
;
3822 CORE_ADDR ipa_error_tracepoint
;
3824 trace_debug ("lib stopped at stop_tracing");
3826 read_inferior_integer (ipa_sym_addrs
.addr_trace_buffer_is_full
,
3827 &ipa_trace_buffer_is_full
);
3829 read_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
,
3830 &ipa_stopping_tracepoint
);
3831 write_inferior_data_pointer (ipa_sym_addrs
.addr_stopping_tracepoint
, 0);
3833 read_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
,
3834 &ipa_error_tracepoint
);
3835 write_inferior_data_pointer (ipa_sym_addrs
.addr_error_tracepoint
, 0);
3837 read_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
,
3838 &ipa_expr_eval_result
);
3839 write_inferior_integer (ipa_sym_addrs
.addr_expr_eval_result
, 0);
3841 trace_debug ("lib: trace_buffer_is_full: %d, "
3842 "stopping_tracepoint: %s, "
3843 "ipa_expr_eval_result: %d, "
3844 "error_tracepoint: %s, ",
3845 ipa_trace_buffer_is_full
,
3846 paddress (ipa_stopping_tracepoint
),
3847 ipa_expr_eval_result
,
3848 paddress (ipa_error_tracepoint
));
3852 if (ipa_trace_buffer_is_full
)
3853 trace_debug ("lib stopped due to full buffer.");
3854 if (ipa_stopping_tracepoint
)
3855 trace_debug ("lib stopped due to tpoint");
3856 if (ipa_stopping_tracepoint
)
3857 trace_debug ("lib stopped due to error");
3860 if (ipa_stopping_tracepoint
!= 0)
3863 = fast_tracepoint_from_ipa_tpoint_address (ipa_stopping_tracepoint
);
3865 else if (ipa_expr_eval_result
!= expr_eval_no_error
)
3867 expr_eval_result
= ipa_expr_eval_result
;
3869 = fast_tracepoint_from_ipa_tpoint_address (ipa_error_tracepoint
);
3874 else if (stop_pc
== ipa_sym_addrs
.addr_flush_trace_buffer
)
3876 trace_debug ("lib stopped at flush_trace_buffer");
3883 /* Return true if TINFO just hit a tracepoint. Collect data if
3887 tracepoint_was_hit (struct thread_info
*tinfo
, CORE_ADDR stop_pc
)
3889 struct tracepoint
*tpoint
;
3891 struct trap_tracepoint_ctx ctx
;
3893 /* Not tracing, don't handle. */
3897 ctx
.base
.type
= trap_tracepoint
;
3898 ctx
.regcache
= get_thread_regcache (tinfo
, 1);
3900 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
3902 /* Note that we collect fast tracepoints here as well. We'll
3903 step over the fast tracepoint jump later, which avoids the
3905 if (tpoint
->enabled
&& stop_pc
== tpoint
->address
)
3907 trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
3908 target_pid_to_str (tinfo
->entry
.id
),
3909 tpoint
->number
, paddress (tpoint
->address
));
3911 /* Test the condition if present, and collect if true. */
3913 || (condition_true_at_tracepoint
3914 ((struct tracepoint_hit_ctx
*) &ctx
, tpoint
)))
3915 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
3918 if (stopping_tracepoint
3919 || trace_buffer_is_full
3920 || expr_eval_result
!= expr_eval_no_error
)
3924 /* If the tracepoint had a 'while-stepping' action, then set
3925 the thread to collect this tracepoint on the following
3927 else if (tpoint
->step_count
> 0)
3929 add_while_stepping_state (tinfo
,
3930 tpoint
->number
, tpoint
->address
);
3942 #if defined IN_PROCESS_AGENT && defined HAVE_UST
3943 struct ust_marker_data
;
3944 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
3946 struct tracepoint
*tpoint
,
3947 struct traceframe
*tframe
);
3950 /* Create a trace frame for the hit of the given tracepoint in the
3954 collect_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
, CORE_ADDR stop_pc
,
3955 struct tracepoint
*tpoint
)
3957 struct traceframe
*tframe
;
3960 /* Only count it as a hit when we actually collect data. */
3961 tpoint
->hit_count
++;
3963 /* If we've exceeded a defined pass count, record the event for
3964 later, and finish the collection for this hit. This test is only
3965 for nonstepping tracepoints, stepping tracepoints test at the end
3966 of their while-stepping loop. */
3967 if (tpoint
->pass_count
> 0
3968 && tpoint
->hit_count
>= tpoint
->pass_count
3969 && tpoint
->step_count
== 0
3970 && stopping_tracepoint
== NULL
)
3971 stopping_tracepoint
= tpoint
;
3973 trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %ld",
3974 tpoint
->number
, paddress (tpoint
->address
), tpoint
->hit_count
);
3976 tframe
= add_traceframe (tpoint
);
3980 for (acti
= 0; acti
< tpoint
->numactions
; ++acti
)
3982 #ifndef IN_PROCESS_AGENT
3983 trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
3984 tpoint
->number
, paddress (tpoint
->address
),
3985 tpoint
->actions_str
[acti
]);
3988 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
3989 tpoint
->actions
[acti
]);
3992 finish_traceframe (tframe
);
3995 if (tframe
== NULL
&& tracing
)
3996 trace_buffer_is_full
= 1;
3999 #ifndef IN_PROCESS_AGENT
4002 collect_data_at_step (struct tracepoint_hit_ctx
*ctx
,
4004 struct tracepoint
*tpoint
, int current_step
)
4006 struct traceframe
*tframe
;
4009 trace_debug ("Making new step traceframe for "
4010 "tracepoint %d at 0x%s, step %d of %ld, hit %ld",
4011 tpoint
->number
, paddress (tpoint
->address
),
4012 current_step
, tpoint
->step_count
,
4015 tframe
= add_traceframe (tpoint
);
4019 for (acti
= 0; acti
< tpoint
->num_step_actions
; ++acti
)
4021 trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'",
4022 tpoint
->number
, paddress (tpoint
->address
),
4023 tpoint
->step_actions_str
[acti
]);
4025 do_action_at_tracepoint (ctx
, stop_pc
, tpoint
, tframe
,
4026 tpoint
->step_actions
[acti
]);
4029 finish_traceframe (tframe
);
4032 if (tframe
== NULL
&& tracing
)
4033 trace_buffer_is_full
= 1;
4038 static struct regcache
*
4039 get_context_regcache (struct tracepoint_hit_ctx
*ctx
)
4041 struct regcache
*regcache
= NULL
;
4043 #ifdef IN_PROCESS_AGENT
4044 if (ctx
->type
== fast_tracepoint
)
4046 struct fast_tracepoint_ctx
*fctx
= (struct fast_tracepoint_ctx
*) ctx
;
4047 if (!fctx
->regcache_initted
)
4049 fctx
->regcache_initted
= 1;
4050 init_register_cache (&fctx
->regcache
, fctx
->regspace
);
4051 supply_regblock (&fctx
->regcache
, NULL
);
4052 supply_fast_tracepoint_registers (&fctx
->regcache
, fctx
->regs
);
4054 regcache
= &fctx
->regcache
;
4057 if (ctx
->type
== static_tracepoint
)
4059 struct static_tracepoint_ctx
*sctx
4060 = (struct static_tracepoint_ctx
*) ctx
;
4062 if (!sctx
->regcache_initted
)
4064 sctx
->regcache_initted
= 1;
4065 init_register_cache (&sctx
->regcache
, sctx
->regspace
);
4066 supply_regblock (&sctx
->regcache
, NULL
);
4067 /* Pass down the tracepoint address, because REGS doesn't
4068 include the PC, but we know what it must have been. */
4069 supply_static_tracepoint_registers (&sctx
->regcache
,
4070 (const unsigned char *)
4072 sctx
->tpoint
->address
);
4074 regcache
= &sctx
->regcache
;
4078 if (ctx
->type
== trap_tracepoint
)
4080 struct trap_tracepoint_ctx
*tctx
= (struct trap_tracepoint_ctx
*) ctx
;
4081 regcache
= tctx
->regcache
;
4085 gdb_assert (regcache
!= NULL
);
4091 do_action_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4093 struct tracepoint
*tpoint
,
4094 struct traceframe
*tframe
,
4095 struct tracepoint_action
*taction
)
4097 enum eval_result_type err
;
4099 switch (taction
->type
)
4103 struct collect_memory_action
*maction
;
4105 maction
= (struct collect_memory_action
*) taction
;
4107 trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
4108 pulongest (maction
->len
),
4109 paddress (maction
->addr
), maction
->basereg
);
4110 /* (should use basereg) */
4111 agent_mem_read (tframe
, NULL
,
4112 (CORE_ADDR
) maction
->addr
, maction
->len
);
4117 unsigned char *regspace
;
4118 struct regcache tregcache
;
4119 struct regcache
*context_regcache
;
4122 trace_debug ("Want to collect registers");
4124 /* Collect all registers for now. */
4125 regspace
= add_traceframe_block (tframe
,
4126 1 + register_cache_size ());
4127 if (regspace
== NULL
)
4129 trace_debug ("Trace buffer block allocation failed, skipping");
4132 /* Identify a register block. */
4135 context_regcache
= get_context_regcache (ctx
);
4137 /* Wrap the regblock in a register cache (in the stack, we
4138 don't want to malloc here). */
4139 init_register_cache (&tregcache
, regspace
+ 1);
4141 /* Copy the register data to the regblock. */
4142 regcache_cpy (&tregcache
, context_regcache
);
4144 #ifndef IN_PROCESS_AGENT
4145 /* On some platforms, trap-based tracepoints will have the PC
4146 pointing to the next instruction after the trap, but we
4147 don't want the user or GDB trying to guess whether the
4148 saved PC needs adjusting; so always record the adjusted
4149 stop_pc. Note that we can't use tpoint->address instead,
4150 since it will be wrong for while-stepping actions. This
4151 adjustment is a nop for fast tracepoints collected from the
4152 in-process lib (but not if GDBserver is collecting one
4153 preemptively), since the PC had already been adjusted to
4154 contain the tracepoint's address by the jump pad. */
4155 trace_debug ("Storing stop pc (0x%s) in regblock",
4156 paddress (tpoint
->address
));
4158 /* This changes the regblock, not the thread's
4160 regcache_write_pc (&tregcache
, stop_pc
);
4166 struct eval_expr_action
*eaction
;
4168 eaction
= (struct eval_expr_action
*) taction
;
4170 trace_debug ("Want to evaluate expression");
4172 err
= eval_agent_expr (ctx
, tframe
, eaction
->expr
, NULL
);
4174 if (err
!= expr_eval_no_error
)
4176 record_tracepoint_error (tpoint
, "action expression", err
);
4183 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4184 trace_debug ("Want to collect static trace data");
4185 collect_ust_data_at_tracepoint (ctx
, stop_pc
,
4188 trace_debug ("warning: collecting static trace data, "
4189 "but static tracepoints are not supported");
4194 trace_debug ("unknown trace action '%c', ignoring", taction
->type
);
4200 condition_true_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
4201 struct tracepoint
*tpoint
)
4204 enum eval_result_type err
;
4206 /* Presently, gdbserver doesn't run compiled conditions, only the
4207 IPA does. If the program stops at a fast tracepoint's address
4208 (e.g., due to a breakpoint, trap tracepoint, or stepping),
4209 gdbserver preemptively collect the fast tracepoint. Later, on
4210 resume, gdbserver steps over the fast tracepoint like it steps
4211 over breakpoints, so that the IPA doesn't see that fast
4212 tracepoint. This avoids double collects of fast tracepoints in
4213 that stopping scenario. Having gdbserver itself handle the fast
4214 tracepoint gives the user a consistent view of when fast or trap
4215 tracepoints are collected, compared to an alternative where only
4216 trap tracepoints are collected on stop, and fast tracepoints on
4217 resume. When a fast tracepoint is being processed by gdbserver,
4218 it is always the non-compiled condition expression that is
4220 #ifdef IN_PROCESS_AGENT
4221 if (tpoint
->compiled_cond
)
4222 err
= ((condfn
) (uintptr_t) (tpoint
->compiled_cond
)) (ctx
, &value
);
4225 err
= eval_agent_expr (ctx
, NULL
, tpoint
->cond
, &value
);
4227 if (err
!= expr_eval_no_error
)
4229 record_tracepoint_error (tpoint
, "condition", err
);
4230 /* The error case must return false. */
4234 trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
4235 tpoint
->number
, paddress (tpoint
->address
),
4237 return (value
? 1 : 0);
4240 #ifndef IN_PROCESS_AGENT
4242 /* The packet form of an agent expression consists of an 'X', number
4243 of bytes in expression, a comma, and then the bytes. */
4245 static struct agent_expr
*
4246 parse_agent_expr (char **actparm
)
4248 char *act
= *actparm
;
4250 struct agent_expr
*aexpr
;
4252 ++act
; /* skip the X */
4253 act
= unpack_varlen_hex (act
, &xlen
);
4254 ++act
; /* skip a comma */
4255 aexpr
= xmalloc (sizeof (struct agent_expr
));
4256 aexpr
->length
= xlen
;
4257 aexpr
->bytes
= xmalloc (xlen
);
4258 convert_ascii_to_int (act
, aexpr
->bytes
, xlen
);
4259 *actparm
= act
+ (xlen
* 2);
4263 /* Convert the bytes of an agent expression back into hex digits, so
4264 they can be printed or uploaded. This allocates the buffer,
4265 callers should free when they are done with it. */
4268 unparse_agent_expr (struct agent_expr
*aexpr
)
4272 rslt
= xmalloc (2 * aexpr
->length
+ 1);
4273 convert_int_to_ascii (aexpr
->bytes
, rslt
, aexpr
->length
);
4279 /* A wrapper for gdb_agent_op_names that does some bounds-checking. */
4282 gdb_agent_op_name (int op
)
4284 if (op
< 0 || op
>= gdb_agent_op_last
|| gdb_agent_op_names
[op
] == NULL
)
4286 return gdb_agent_op_names
[op
];
4289 /* The agent expression evaluator, as specified by the GDB docs. It
4290 returns 0 if everything went OK, and a nonzero error code
4293 static enum eval_result_type
4294 eval_agent_expr (struct tracepoint_hit_ctx
*ctx
,
4295 struct traceframe
*tframe
,
4296 struct agent_expr
*aexpr
,
4300 #define STACK_MAX 100
4301 ULONGEST stack
[STACK_MAX
], top
;
4306 /* This union is a convenient way to convert representations. For
4307 now, assume a standard architecture where the hardware integer
4308 types have 8, 16, 32, 64 bit types. A more robust solution would
4309 be to import stdint.h from gnulib. */
4314 unsigned char bytes
[1];
4319 unsigned char bytes
[2];
4324 unsigned char bytes
[4];
4329 unsigned char bytes
[8];
4334 if (aexpr
->length
== 0)
4336 trace_debug ("empty agent expression");
4337 return expr_eval_empty_expression
;
4340 /* Cache the stack top in its own variable. Much of the time we can
4341 operate on this variable, rather than dinking with the stack. It
4342 needs to be copied to the stack when sp changes. */
4347 op
= aexpr
->bytes
[pc
++];
4349 trace_debug ("About to interpret byte 0x%x", op
);
4353 case gdb_agent_op_add
:
4357 case gdb_agent_op_sub
:
4358 top
= stack
[--sp
] - top
;
4361 case gdb_agent_op_mul
:
4365 case gdb_agent_op_div_signed
:
4368 trace_debug ("Attempted to divide by zero");
4369 return expr_eval_divide_by_zero
;
4371 top
= ((LONGEST
) stack
[--sp
]) / ((LONGEST
) top
);
4374 case gdb_agent_op_div_unsigned
:
4377 trace_debug ("Attempted to divide by zero");
4378 return expr_eval_divide_by_zero
;
4380 top
= stack
[--sp
] / top
;
4383 case gdb_agent_op_rem_signed
:
4386 trace_debug ("Attempted to divide by zero");
4387 return expr_eval_divide_by_zero
;
4389 top
= ((LONGEST
) stack
[--sp
]) % ((LONGEST
) top
);
4392 case gdb_agent_op_rem_unsigned
:
4395 trace_debug ("Attempted to divide by zero");
4396 return expr_eval_divide_by_zero
;
4398 top
= stack
[--sp
] % top
;
4401 case gdb_agent_op_lsh
:
4402 top
= stack
[--sp
] << top
;
4405 case gdb_agent_op_rsh_signed
:
4406 top
= ((LONGEST
) stack
[--sp
]) >> top
;
4409 case gdb_agent_op_rsh_unsigned
:
4410 top
= stack
[--sp
] >> top
;
4413 case gdb_agent_op_trace
:
4414 agent_mem_read (tframe
,
4415 NULL
, (CORE_ADDR
) stack
[--sp
], (ULONGEST
) top
);
4420 case gdb_agent_op_trace_quick
:
4421 arg
= aexpr
->bytes
[pc
++];
4422 agent_mem_read (tframe
, NULL
, (CORE_ADDR
) top
, (ULONGEST
) arg
);
4425 case gdb_agent_op_log_not
:
4429 case gdb_agent_op_bit_and
:
4433 case gdb_agent_op_bit_or
:
4437 case gdb_agent_op_bit_xor
:
4441 case gdb_agent_op_bit_not
:
4445 case gdb_agent_op_equal
:
4446 top
= (stack
[--sp
] == top
);
4449 case gdb_agent_op_less_signed
:
4450 top
= (((LONGEST
) stack
[--sp
]) < ((LONGEST
) top
));
4453 case gdb_agent_op_less_unsigned
:
4454 top
= (stack
[--sp
] < top
);
4457 case gdb_agent_op_ext
:
4458 arg
= aexpr
->bytes
[pc
++];
4459 if (arg
< (sizeof (LONGEST
) * 8))
4461 LONGEST mask
= 1 << (arg
- 1);
4462 top
&= ((LONGEST
) 1 << arg
) - 1;
4463 top
= (top
^ mask
) - mask
;
4467 case gdb_agent_op_ref8
:
4468 agent_mem_read (tframe
, cnv
.u8
.bytes
, (CORE_ADDR
) top
, 1);
4472 case gdb_agent_op_ref16
:
4473 agent_mem_read (tframe
, cnv
.u16
.bytes
, (CORE_ADDR
) top
, 2);
4477 case gdb_agent_op_ref32
:
4478 agent_mem_read (tframe
, cnv
.u32
.bytes
, (CORE_ADDR
) top
, 4);
4482 case gdb_agent_op_ref64
:
4483 agent_mem_read (tframe
, cnv
.u64
.bytes
, (CORE_ADDR
) top
, 8);
4487 case gdb_agent_op_if_goto
:
4489 pc
= (aexpr
->bytes
[pc
] << 8) + (aexpr
->bytes
[pc
+ 1]);
4496 case gdb_agent_op_goto
:
4497 pc
= (aexpr
->bytes
[pc
] << 8) + (aexpr
->bytes
[pc
+ 1]);
4500 case gdb_agent_op_const8
:
4501 /* Flush the cached stack top. */
4503 top
= aexpr
->bytes
[pc
++];
4506 case gdb_agent_op_const16
:
4507 /* Flush the cached stack top. */
4509 top
= aexpr
->bytes
[pc
++];
4510 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4513 case gdb_agent_op_const32
:
4514 /* Flush the cached stack top. */
4516 top
= aexpr
->bytes
[pc
++];
4517 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4518 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4519 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4522 case gdb_agent_op_const64
:
4523 /* Flush the cached stack top. */
4525 top
= aexpr
->bytes
[pc
++];
4526 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4527 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4528 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4529 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4530 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4531 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4532 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
4535 case gdb_agent_op_reg
:
4536 /* Flush the cached stack top. */
4538 arg
= aexpr
->bytes
[pc
++];
4539 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
4542 struct regcache
*regcache
;
4544 regcache
= get_context_regcache (ctx
);
4546 switch (register_size (regnum
))
4549 collect_register (regcache
, regnum
, cnv
.u64
.bytes
);
4553 collect_register (regcache
, regnum
, cnv
.u32
.bytes
);
4557 collect_register (regcache
, regnum
, cnv
.u16
.bytes
);
4561 collect_register (regcache
, regnum
, cnv
.u8
.bytes
);
4565 internal_error (__FILE__
, __LINE__
,
4566 "unhandled register size");
4571 case gdb_agent_op_end
:
4572 trace_debug ("At end of expression, sp=%d, stack top cache=0x%s",
4573 sp
, pulongest (top
));
4578 /* This should be an error */
4579 trace_debug ("Stack is empty, nothing to return");
4580 return expr_eval_empty_stack
;
4584 return expr_eval_no_error
;
4586 case gdb_agent_op_dup
:
4590 case gdb_agent_op_pop
:
4595 case gdb_agent_op_pick
:
4596 arg
= aexpr
->bytes
[pc
++];
4598 top
= stack
[sp
- arg
];
4602 case gdb_agent_op_rot
:
4604 ULONGEST tem
= stack
[sp
- 1];
4606 stack
[sp
- 1] = stack
[sp
- 2];
4607 stack
[sp
- 2] = top
;
4612 case gdb_agent_op_zero_ext
:
4613 arg
= aexpr
->bytes
[pc
++];
4614 if (arg
< (sizeof (LONGEST
) * 8))
4615 top
&= ((LONGEST
) 1 << arg
) - 1;
4618 case gdb_agent_op_swap
:
4619 /* Interchange top two stack elements, making sure top gets
4620 copied back onto stack. */
4622 top
= stack
[sp
- 1];
4623 stack
[sp
- 1] = stack
[sp
];
4626 case gdb_agent_op_getv
:
4627 /* Flush the cached stack top. */
4629 arg
= aexpr
->bytes
[pc
++];
4630 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
4631 top
= get_trace_state_variable_value (arg
);
4634 case gdb_agent_op_setv
:
4635 arg
= aexpr
->bytes
[pc
++];
4636 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
4637 set_trace_state_variable_value (arg
, top
);
4638 /* Note that we leave the value on the stack, for the
4639 benefit of later/enclosing expressions. */
4642 case gdb_agent_op_tracev
:
4643 arg
= aexpr
->bytes
[pc
++];
4644 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
4645 agent_tsv_read (tframe
, arg
);
4648 /* GDB never (currently) generates any of these ops. */
4649 case gdb_agent_op_float
:
4650 case gdb_agent_op_ref_float
:
4651 case gdb_agent_op_ref_double
:
4652 case gdb_agent_op_ref_long_double
:
4653 case gdb_agent_op_l_to_d
:
4654 case gdb_agent_op_d_to_l
:
4655 case gdb_agent_op_trace16
:
4656 trace_debug ("Agent expression op 0x%x valid, but not handled",
4658 /* If ever GDB generates any of these, we don't have the
4659 option of ignoring. */
4663 trace_debug ("Agent expression op 0x%x not recognized", op
);
4664 /* Don't struggle on, things will just get worse. */
4665 return expr_eval_unrecognized_opcode
;
4668 /* Check for stack badness. */
4669 if (sp
>= (STACK_MAX
- 1))
4671 trace_debug ("Expression stack overflow");
4672 return expr_eval_stack_overflow
;
4677 trace_debug ("Expression stack underflow");
4678 return expr_eval_stack_underflow
;
4681 trace_debug ("Op %s -> sp=%d, top=0x%s",
4682 gdb_agent_op_name (op
), sp
, pulongest (top
));
4686 /* Do memory copies for bytecodes. */
4687 /* Do the recording of memory blocks for actions and bytecodes. */
4690 agent_mem_read (struct traceframe
*tframe
,
4691 unsigned char *to
, CORE_ADDR from
, ULONGEST len
)
4693 unsigned char *mspace
;
4694 ULONGEST remaining
= len
;
4695 unsigned short blocklen
;
4697 /* If a 'to' buffer is specified, use it. */
4700 read_inferior_memory (from
, to
, len
);
4704 /* Otherwise, create a new memory block in the trace buffer. */
4705 while (remaining
> 0)
4709 blocklen
= (remaining
> 65535 ? 65535 : remaining
);
4710 sp
= 1 + sizeof (from
) + sizeof (blocklen
) + blocklen
;
4711 mspace
= add_traceframe_block (tframe
, sp
);
4714 /* Identify block as a memory block. */
4717 /* Record address and size. */
4718 memcpy (mspace
, &from
, sizeof (from
));
4719 mspace
+= sizeof (from
);
4720 memcpy (mspace
, &blocklen
, sizeof (blocklen
));
4721 mspace
+= sizeof (blocklen
);
4722 /* Record the memory block proper. */
4723 read_inferior_memory (from
, mspace
, blocklen
);
4724 trace_debug ("%d bytes recorded", blocklen
);
4725 remaining
-= blocklen
;
4731 /* Record the value of a trace state variable. */
4734 agent_tsv_read (struct traceframe
*tframe
, int n
)
4736 unsigned char *vspace
;
4739 vspace
= add_traceframe_block (tframe
,
4740 1 + sizeof (n
) + sizeof (LONGEST
));
4743 /* Identify block as a variable. */
4745 /* Record variable's number and value. */
4746 memcpy (vspace
+ 1, &n
, sizeof (n
));
4747 val
= get_trace_state_variable_value (n
);
4748 memcpy (vspace
+ 1 + sizeof (n
), &val
, sizeof (val
));
4749 trace_debug ("Variable %d recorded", n
);
4753 #ifndef IN_PROCESS_AGENT
4755 /* Callback for traceframe_walk_blocks, used to find a given block
4756 type in a traceframe. */
4759 match_blocktype (char blocktype
, unsigned char *dataptr
, void *data
)
4761 char *wantedp
= data
;
4763 if (*wantedp
== blocktype
)
4769 /* Walk over all traceframe blocks of the traceframe buffer starting
4770 at DATABASE, of DATASIZE bytes long, and call CALLBACK for each
4771 block found, passing in DATA unmodified. If CALLBACK returns true,
4772 this returns a pointer to where the block is found. Returns NULL
4773 if no callback call returned true, indicating that all blocks have
4776 static unsigned char *
4777 traceframe_walk_blocks (unsigned char *database
, unsigned int datasize
,
4779 int (*callback
) (char blocktype
,
4780 unsigned char *dataptr
,
4784 unsigned char *dataptr
;
4788 trace_debug ("traceframe %d has no data", tfnum
);
4792 /* Iterate through a traceframe's blocks, looking for a block of the
4794 for (dataptr
= database
;
4795 dataptr
< database
+ datasize
;
4799 unsigned short mlen
;
4801 if (dataptr
== trace_buffer_wrap
)
4803 /* Adjust to reflect wrapping part of the frame around to
4805 datasize
= dataptr
- database
;
4806 dataptr
= database
= trace_buffer_lo
;
4809 blocktype
= *dataptr
++;
4811 if ((*callback
) (blocktype
, dataptr
, data
))
4817 /* Skip over the registers block. */
4818 dataptr
+= register_cache_size ();
4821 /* Skip over the memory block. */
4822 dataptr
+= sizeof (CORE_ADDR
);
4823 memcpy (&mlen
, dataptr
, sizeof (mlen
));
4824 dataptr
+= (sizeof (mlen
) + mlen
);
4827 /* Skip over the TSV block. */
4828 dataptr
+= (sizeof (int) + sizeof (LONGEST
));
4831 /* Skip over the static trace data block. */
4832 memcpy (&mlen
, dataptr
, sizeof (mlen
));
4833 dataptr
+= (sizeof (mlen
) + mlen
);
4836 trace_debug ("traceframe %d has unknown block type 0x%x",
4845 /* Look for the block of type TYPE_WANTED in the trameframe starting
4846 at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
4849 static unsigned char *
4850 traceframe_find_block_type (unsigned char *database
, unsigned int datasize
,
4851 int tfnum
, char type_wanted
)
4853 return traceframe_walk_blocks (database
, datasize
, tfnum
,
4854 match_blocktype
, &type_wanted
);
4857 static unsigned char *
4858 traceframe_find_regblock (struct traceframe
*tframe
, int tfnum
)
4860 unsigned char *regblock
;
4862 regblock
= traceframe_find_block_type (tframe
->data
,
4866 if (regblock
== NULL
)
4867 trace_debug ("traceframe %d has no register data", tfnum
);
4872 /* Get registers from a traceframe. */
4875 fetch_traceframe_registers (int tfnum
, struct regcache
*regcache
, int regnum
)
4877 unsigned char *dataptr
;
4878 struct tracepoint
*tpoint
;
4879 struct traceframe
*tframe
;
4881 tframe
= find_traceframe (tfnum
);
4885 trace_debug ("traceframe %d not found", tfnum
);
4889 dataptr
= traceframe_find_regblock (tframe
, tfnum
);
4890 if (dataptr
== NULL
)
4892 /* Mark registers unavailable. */
4893 supply_regblock (regcache
, NULL
);
4895 /* We can generally guess at a PC, although this will be
4896 misleading for while-stepping frames and multi-location
4898 tpoint
= find_next_tracepoint_by_number (NULL
, tframe
->tpnum
);
4900 regcache_write_pc (regcache
, tpoint
->address
);
4903 supply_regblock (regcache
, dataptr
);
4909 traceframe_get_pc (struct traceframe
*tframe
)
4911 struct regcache regcache
;
4912 unsigned char *dataptr
;
4914 dataptr
= traceframe_find_regblock (tframe
, -1);
4915 if (dataptr
== NULL
)
4918 init_register_cache (®cache
, dataptr
);
4919 return regcache_read_pc (®cache
);
4922 /* Read a requested block of memory from a trace frame. */
4925 traceframe_read_mem (int tfnum
, CORE_ADDR addr
,
4926 unsigned char *buf
, ULONGEST length
,
4929 struct traceframe
*tframe
;
4930 unsigned char *database
, *dataptr
;
4931 unsigned int datasize
;
4933 unsigned short mlen
;
4935 trace_debug ("traceframe_read_mem");
4937 tframe
= find_traceframe (tfnum
);
4941 trace_debug ("traceframe %d not found", tfnum
);
4945 datasize
= tframe
->data_size
;
4946 database
= dataptr
= &tframe
->data
[0];
4948 /* Iterate through a traceframe's blocks, looking for memory. */
4949 while ((dataptr
= traceframe_find_block_type (dataptr
,
4951 - (dataptr
- database
),
4952 tfnum
, 'M')) != NULL
)
4954 memcpy (&maddr
, dataptr
, sizeof (maddr
));
4955 dataptr
+= sizeof (maddr
);
4956 memcpy (&mlen
, dataptr
, sizeof (mlen
));
4957 dataptr
+= sizeof (mlen
);
4958 trace_debug ("traceframe %d has %d bytes at %s",
4959 tfnum
, mlen
, paddress (maddr
));
4961 /* If the block includes the first part of the desired range,
4962 return as much it has; GDB will re-request the remainder,
4963 which might be in a different block of this trace frame. */
4964 if (maddr
<= addr
&& addr
< (maddr
+ mlen
))
4966 ULONGEST amt
= (maddr
+ mlen
) - addr
;
4970 memcpy (buf
, dataptr
+ (addr
- maddr
), amt
);
4975 /* Skip over this block. */
4979 trace_debug ("traceframe %d has no memory data for the desired region",
4987 traceframe_read_tsv (int tsvnum
, LONGEST
*val
)
4990 struct traceframe
*tframe
;
4991 unsigned char *database
, *dataptr
;
4992 unsigned int datasize
;
4995 trace_debug ("traceframe_read_tsv");
4997 tfnum
= current_traceframe
;
5001 trace_debug ("no current traceframe");
5005 tframe
= find_traceframe (tfnum
);
5009 trace_debug ("traceframe %d not found", tfnum
);
5013 datasize
= tframe
->data_size
;
5014 database
= dataptr
= &tframe
->data
[0];
5016 /* Iterate through a traceframe's blocks, looking for the tsv. */
5017 while ((dataptr
= traceframe_find_block_type (dataptr
,
5019 - (dataptr
- database
),
5020 tfnum
, 'V')) != NULL
)
5022 memcpy (&vnum
, dataptr
, sizeof (vnum
));
5023 dataptr
+= sizeof (vnum
);
5025 trace_debug ("traceframe %d has variable %d", tfnum
, vnum
);
5027 /* Check that this is the variable we want. */
5030 memcpy (val
, dataptr
, sizeof (*val
));
5034 /* Skip over this block. */
5035 dataptr
+= sizeof (LONGEST
);
5038 trace_debug ("traceframe %d has no data for variable %d",
5043 /* Read a requested block of static tracepoint data from a trace
5047 traceframe_read_sdata (int tfnum
, ULONGEST offset
,
5048 unsigned char *buf
, ULONGEST length
,
5051 struct traceframe
*tframe
;
5052 unsigned char *database
, *dataptr
;
5053 unsigned int datasize
;
5054 unsigned short mlen
;
5056 trace_debug ("traceframe_read_sdata");
5058 tframe
= find_traceframe (tfnum
);
5062 trace_debug ("traceframe %d not found", tfnum
);
5066 datasize
= tframe
->data_size
;
5067 database
= &tframe
->data
[0];
5069 /* Iterate through a traceframe's blocks, looking for static
5071 dataptr
= traceframe_find_block_type (database
, datasize
,
5073 if (dataptr
!= NULL
)
5075 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5076 dataptr
+= sizeof (mlen
);
5079 if (offset
+ length
> mlen
)
5080 length
= mlen
- offset
;
5082 memcpy (buf
, dataptr
, length
);
5090 trace_debug ("traceframe %d has no static trace data", tfnum
);
5096 /* Callback for traceframe_walk_blocks. Builds a traceframe-info
5097 object. DATA is pointer to a struct buffer holding the
5098 traceframe-info object being built. */
5101 build_traceframe_info_xml (char blocktype
, unsigned char *dataptr
, void *data
)
5103 struct buffer
*buffer
= data
;
5109 unsigned short mlen
;
5112 memcpy (&maddr
, dataptr
, sizeof (maddr
));
5113 dataptr
+= sizeof (maddr
);
5114 memcpy (&mlen
, dataptr
, sizeof (mlen
));
5115 dataptr
+= sizeof (mlen
);
5116 buffer_xml_printf (buffer
,
5117 "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5118 paddress (maddr
), phex_nz (mlen
, sizeof (mlen
)));
5128 warning ("Unhandled trace block type (%d) '%c ' "
5129 "while building trace frame info.",
5130 blocktype
, blocktype
);
5137 /* Build a traceframe-info object for traceframe number TFNUM into
5141 traceframe_read_info (int tfnum
, struct buffer
*buffer
)
5143 struct traceframe
*tframe
;
5145 trace_debug ("traceframe_read_info");
5147 tframe
= find_traceframe (tfnum
);
5151 trace_debug ("traceframe %d not found", tfnum
);
5155 buffer_grow_str (buffer
, "<traceframe-info>\n");
5156 traceframe_walk_blocks (tframe
->data
, tframe
->data_size
,
5157 tfnum
, build_traceframe_info_xml
, buffer
);
5158 buffer_grow_str0 (buffer
, "</traceframe-info>\n");
5162 /* Return the first fast tracepoint whose jump pad contains PC. */
5164 static struct tracepoint
*
5165 fast_tracepoint_from_jump_pad_address (CORE_ADDR pc
)
5167 struct tracepoint
*tpoint
;
5169 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5170 if (tpoint
->type
== fast_tracepoint
)
5171 if (tpoint
->jump_pad
<= pc
&& pc
< tpoint
->jump_pad_end
)
5177 /* Return GDBserver's tracepoint that matches the IP Agent's
5178 tracepoint object that lives at IPA_TPOINT_OBJ in the IP Agent's
5181 static struct tracepoint
*
5182 fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR ipa_tpoint_obj
)
5184 struct tracepoint
*tpoint
;
5186 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
5187 if (tpoint
->type
== fast_tracepoint
)
5188 if (tpoint
->obj_addr_on_target
== ipa_tpoint_obj
)
5196 /* The type of the object that is used to synchronize fast tracepoint
5199 typedef struct collecting_t
5201 /* The fast tracepoint number currently collecting. */
5204 /* A number that GDBserver can use to identify the thread that is
5205 presently holding the collect lock. This need not (and usually
5206 is not) the thread id, as getting the current thread ID usually
5207 requires a system call, which we want to avoid like the plague.
5208 Usually this is thread's TCB, found in the TLS (pseudo-)
5209 register, which is readable with a single insn on several
5211 uintptr_t thread_area
;
5214 #ifndef IN_PROCESS_AGENT
5217 force_unlock_trace_buffer (void)
5219 write_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
, 0);
5222 /* Check if the thread identified by THREAD_AREA which is stopped at
5223 STOP_PC, is presently locking the fast tracepoint collection, and
5224 if so, gather some status of said collection. Returns 0 if the
5225 thread isn't collecting or in the jump pad at all. 1, if in the
5226 jump pad (or within gdb_collect) and hasn't executed the adjusted
5227 original insn yet (can set a breakpoint there and run to it). 2,
5228 if presently executing the adjusted original insn --- in which
5229 case, if we want to move the thread out of the jump pad, we need to
5230 single-step it until this function returns 0. */
5233 fast_tracepoint_collecting (CORE_ADDR thread_area
,
5235 struct fast_tpoint_collect_status
*status
)
5237 CORE_ADDR ipa_collecting
;
5238 CORE_ADDR ipa_gdb_jump_pad_buffer
, ipa_gdb_jump_pad_buffer_end
;
5239 struct tracepoint
*tpoint
;
5240 int needs_breakpoint
;
5242 /* The thread THREAD_AREA is either:
5244 0. not collecting at all, not within the jump pad, or within
5245 gdb_collect or one of its callees.
5247 1. in the jump pad and haven't reached gdb_collect
5249 2. within gdb_collect (out of the jump pad) (collect is set)
5251 3. we're in the jump pad, after gdb_collect having returned,
5252 possibly executing the adjusted insns.
5254 For cases 1 and 3, `collecting' may or not be set. The jump pad
5255 doesn't have any complicated jump logic, so we can tell if the
5256 thread is executing the adjust original insn or not by just
5257 matching STOP_PC with known jump pad addresses. If we it isn't
5258 yet executing the original insn, set a breakpoint there, and let
5259 the thread run to it, so to quickly step over a possible (many
5260 insns) gdb_collect call. Otherwise, or when the breakpoint is
5261 hit, only a few (small number of) insns are left to be executed
5262 in the jump pad. Single-step the thread until it leaves the
5267 needs_breakpoint
= 0;
5268 trace_debug ("fast_tracepoint_collecting");
5270 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer
,
5271 &ipa_gdb_jump_pad_buffer
))
5272 fatal ("error extracting `gdb_jump_pad_buffer'");
5273 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_jump_pad_buffer_end
,
5274 &ipa_gdb_jump_pad_buffer_end
))
5275 fatal ("error extracting `gdb_jump_pad_buffer_end'");
5277 if (ipa_gdb_jump_pad_buffer
<= stop_pc
5278 && stop_pc
< ipa_gdb_jump_pad_buffer_end
)
5280 /* We can tell which tracepoint(s) the thread is collecting by
5281 matching the jump pad address back to the tracepoint. */
5282 tpoint
= fast_tracepoint_from_jump_pad_address (stop_pc
);
5285 warning ("in jump pad, but no matching tpoint?");
5290 trace_debug ("in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5292 tpoint
->number
, paddress (tpoint
->address
),
5293 paddress (tpoint
->jump_pad
),
5294 paddress (tpoint
->jump_pad_end
),
5295 paddress (tpoint
->adjusted_insn_addr
),
5296 paddress (tpoint
->adjusted_insn_addr_end
));
5299 /* Definitely in the jump pad. May or may not need
5300 fast-exit-jump-pad breakpoint. */
5301 if (tpoint
->jump_pad
<= stop_pc
5302 && stop_pc
< tpoint
->adjusted_insn_addr
)
5303 needs_breakpoint
= 1;
5307 collecting_t ipa_collecting_obj
;
5309 /* If `collecting' is set/locked, then the THREAD_AREA thread
5310 may or not be the one holding the lock. We have to read the
5311 lock to find out. */
5313 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_collecting
,
5316 trace_debug ("fast_tracepoint_collecting:"
5317 " failed reading 'collecting' in the inferior");
5321 if (!ipa_collecting
)
5323 trace_debug ("fast_tracepoint_collecting: not collecting"
5324 " (and nobody is).");
5328 /* Some thread is collecting. Check which. */
5329 if (read_inferior_memory (ipa_collecting
,
5330 (unsigned char *) &ipa_collecting_obj
,
5331 sizeof (ipa_collecting_obj
)) != 0)
5334 if (ipa_collecting_obj
.thread_area
!= thread_area
)
5336 trace_debug ("fast_tracepoint_collecting: not collecting "
5337 "(another thread is)");
5342 = fast_tracepoint_from_ipa_tpoint_address (ipa_collecting_obj
.tpoint
);
5345 warning ("fast_tracepoint_collecting: collecting, "
5346 "but tpoint %s not found?",
5347 paddress ((CORE_ADDR
) ipa_collecting_obj
.tpoint
));
5351 /* The thread is within `gdb_collect', skip over the rest of
5352 fast tracepoint collection quickly using a breakpoint. */
5353 needs_breakpoint
= 1;
5356 /* The caller wants a bit of status detail. */
5359 status
->tpoint_num
= tpoint
->number
;
5360 status
->tpoint_addr
= tpoint
->address
;
5361 status
->adjusted_insn_addr
= tpoint
->adjusted_insn_addr
;
5362 status
->adjusted_insn_addr_end
= tpoint
->adjusted_insn_addr_end
;
5365 if (needs_breakpoint
)
5367 /* Hasn't executed the original instruction yet. Set breakpoint
5368 there, and wait till it's hit, then single-step until exiting
5372 fast_tracepoint_collecting, returning continue-until-break at %s",
5373 paddress (tpoint
->adjusted_insn_addr
));
5375 return 1; /* continue */
5379 /* Just single-step until exiting the jump pad. */
5381 trace_debug ("fast_tracepoint_collecting, returning "
5382 "need-single-step (%s-%s)",
5383 paddress (tpoint
->adjusted_insn_addr
),
5384 paddress (tpoint
->adjusted_insn_addr_end
));
5386 return 2; /* single-step */
5392 #ifdef IN_PROCESS_AGENT
5394 /* The global fast tracepoint collect lock. Points to a collecting_t
5395 object built on the stack by the jump pad, if presently locked;
5396 NULL if it isn't locked. Note that this lock *must* be set while
5397 executing any *function other than the jump pad. See
5398 fast_tracepoint_collecting. */
5399 static collecting_t
* ATTR_USED collecting
;
5401 /* This routine, called from the jump pad (in asm) is designed to be
5402 called from the jump pads of fast tracepoints, thus it is on the
5405 IP_AGENT_EXPORT
void ATTR_USED
5406 gdb_collect (struct tracepoint
*tpoint
, unsigned char *regs
)
5408 struct fast_tracepoint_ctx ctx
;
5410 /* Don't do anything until the trace run is completely set up. */
5414 if (!tpoint
->enabled
)
5417 ctx
.base
.type
= fast_tracepoint
;
5419 ctx
.regcache_initted
= 0;
5420 ctx
.tpoint
= tpoint
;
5422 /* Wrap the regblock in a register cache (in the stack, we don't
5423 want to malloc here). */
5424 ctx
.regspace
= alloca (register_cache_size ());
5425 if (ctx
.regspace
== NULL
)
5427 trace_debug ("Trace buffer block allocation failed, skipping");
5431 /* Test the condition if present, and collect if true. */
5432 if (tpoint
->cond
== NULL
5433 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5436 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
5437 tpoint
->address
, tpoint
);
5439 /* Note that this will cause original insns to be written back
5440 to where we jumped from, but that's OK because we're jumping
5441 back to the next whole instruction. This will go badly if
5442 instruction restoration is not atomic though. */
5443 if (stopping_tracepoint
5444 || trace_buffer_is_full
5445 || expr_eval_result
!= expr_eval_no_error
)
5450 /* If there was a condition and it evaluated to false, the only
5451 way we would stop tracing is if there was an error during
5452 condition expression evaluation. */
5453 if (expr_eval_result
!= expr_eval_no_error
)
5460 #ifndef IN_PROCESS_AGENT
5462 /* Bytecode compilation. */
5464 CORE_ADDR current_insn_ptr
;
5468 struct bytecode_address
5473 /* Offset and size of field to be modified in the goto block. */
5474 int from_offset
, from_size
;
5475 struct bytecode_address
*next
;
5476 } *bytecode_address_table
;
5479 get_raw_reg_func_addr (void)
5481 return ipa_sym_addrs
.addr_get_raw_reg
;
5485 emit_prologue (void)
5487 target_emit_ops ()->emit_prologue ();
5491 emit_epilogue (void)
5493 target_emit_ops ()->emit_epilogue ();
5499 target_emit_ops ()->emit_add ();
5505 target_emit_ops ()->emit_sub ();
5511 target_emit_ops ()->emit_mul ();
5517 target_emit_ops ()->emit_lsh ();
5521 emit_rsh_signed (void)
5523 target_emit_ops ()->emit_rsh_signed ();
5527 emit_rsh_unsigned (void)
5529 target_emit_ops ()->emit_rsh_unsigned ();
5535 target_emit_ops ()->emit_ext (arg
);
5541 target_emit_ops ()->emit_log_not ();
5547 target_emit_ops ()->emit_bit_and ();
5553 target_emit_ops ()->emit_bit_or ();
5559 target_emit_ops ()->emit_bit_xor ();
5565 target_emit_ops ()->emit_bit_not ();
5571 target_emit_ops ()->emit_equal ();
5575 emit_less_signed (void)
5577 target_emit_ops ()->emit_less_signed ();
5581 emit_less_unsigned (void)
5583 target_emit_ops ()->emit_less_unsigned ();
5589 target_emit_ops ()->emit_ref (size
);
5593 emit_if_goto (int *offset_p
, int *size_p
)
5595 target_emit_ops ()->emit_if_goto (offset_p
, size_p
);
5599 emit_goto (int *offset_p
, int *size_p
)
5601 target_emit_ops ()->emit_goto (offset_p
, size_p
);
5605 write_goto_address (CORE_ADDR from
, CORE_ADDR to
, int size
)
5607 target_emit_ops ()->write_goto_address (from
, to
, size
);
5611 emit_const (LONGEST num
)
5613 target_emit_ops ()->emit_const (num
);
5619 target_emit_ops ()->emit_reg (reg
);
5625 target_emit_ops ()->emit_pop ();
5629 emit_stack_flush (void)
5631 target_emit_ops ()->emit_stack_flush ();
5635 emit_zero_ext (int arg
)
5637 target_emit_ops ()->emit_zero_ext (arg
);
5643 target_emit_ops ()->emit_swap ();
5647 emit_stack_adjust (int n
)
5649 target_emit_ops ()->emit_stack_adjust (n
);
5652 /* FN's prototype is `LONGEST(*fn)(int)'. */
5655 emit_int_call_1 (CORE_ADDR fn
, int arg1
)
5657 target_emit_ops ()->emit_int_call_1 (fn
, arg1
);
5660 /* FN's prototype is `void(*fn)(int,LONGEST)'. */
5663 emit_void_call_2 (CORE_ADDR fn
, int arg1
)
5665 target_emit_ops ()->emit_void_call_2 (fn
, arg1
);
5668 static enum eval_result_type
compile_bytecodes (struct agent_expr
*aexpr
);
5671 compile_tracepoint_condition (struct tracepoint
*tpoint
,
5672 CORE_ADDR
*jump_entry
)
5674 CORE_ADDR entry_point
= *jump_entry
;
5675 enum eval_result_type err
;
5677 trace_debug ("Starting condition compilation for tracepoint %d\n",
5680 /* Initialize the global pointer to the code being built. */
5681 current_insn_ptr
= *jump_entry
;
5685 err
= compile_bytecodes (tpoint
->cond
);
5687 if (err
== expr_eval_no_error
)
5691 /* Record the beginning of the compiled code. */
5692 tpoint
->compiled_cond
= entry_point
;
5694 trace_debug ("Condition compilation for tracepoint %d complete\n",
5699 /* Leave the unfinished code in situ, but don't point to it. */
5701 tpoint
->compiled_cond
= 0;
5703 trace_debug ("Condition compilation for tracepoint %d failed, "
5705 tpoint
->number
, err
);
5708 /* Update the code pointer passed in. Note that we do this even if
5709 the compile fails, so that we can look at the partial results
5710 instead of letting them be overwritten. */
5711 *jump_entry
= current_insn_ptr
;
5713 /* Leave a gap, to aid dump decipherment. */
5717 /* Given an agent expression, turn it into native code. */
5719 static enum eval_result_type
5720 compile_bytecodes (struct agent_expr
*aexpr
)
5726 /* This is only used to build 64-bit value for constants. */
5728 struct bytecode_address
*aentry
, *aentry2
;
5733 trace_debug ("Cannot compile op 0x%x\n", op); \
5734 return expr_eval_unhandled_opcode; \
5737 if (aexpr
->length
== 0)
5739 trace_debug ("empty agent expression\n");
5740 return expr_eval_empty_expression
;
5743 bytecode_address_table
= NULL
;
5747 op
= aexpr
->bytes
[pc
];
5749 trace_debug ("About to compile op 0x%x, pc=%d\n", op
, pc
);
5751 /* Record the compiled-code address of the bytecode, for use by
5752 jump instructions. */
5753 aentry
= xmalloc (sizeof (struct bytecode_address
));
5755 aentry
->address
= current_insn_ptr
;
5756 aentry
->goto_pc
= -1;
5757 aentry
->from_offset
= aentry
->from_size
= 0;
5758 aentry
->next
= bytecode_address_table
;
5759 bytecode_address_table
= aentry
;
5767 case gdb_agent_op_add
:
5771 case gdb_agent_op_sub
:
5775 case gdb_agent_op_mul
:
5779 case gdb_agent_op_div_signed
:
5783 case gdb_agent_op_div_unsigned
:
5787 case gdb_agent_op_rem_signed
:
5791 case gdb_agent_op_rem_unsigned
:
5795 case gdb_agent_op_lsh
:
5799 case gdb_agent_op_rsh_signed
:
5803 case gdb_agent_op_rsh_unsigned
:
5804 emit_rsh_unsigned ();
5807 case gdb_agent_op_trace
:
5811 case gdb_agent_op_trace_quick
:
5815 case gdb_agent_op_log_not
:
5819 case gdb_agent_op_bit_and
:
5823 case gdb_agent_op_bit_or
:
5827 case gdb_agent_op_bit_xor
:
5831 case gdb_agent_op_bit_not
:
5835 case gdb_agent_op_equal
:
5839 case gdb_agent_op_less_signed
:
5840 emit_less_signed ();
5843 case gdb_agent_op_less_unsigned
:
5844 emit_less_unsigned ();
5847 case gdb_agent_op_ext
:
5848 arg
= aexpr
->bytes
[pc
++];
5849 if (arg
< (sizeof (LONGEST
) * 8))
5853 case gdb_agent_op_ref8
:
5857 case gdb_agent_op_ref16
:
5861 case gdb_agent_op_ref32
:
5865 case gdb_agent_op_ref64
:
5869 case gdb_agent_op_if_goto
:
5870 arg
= aexpr
->bytes
[pc
++];
5871 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
5872 aentry
->goto_pc
= arg
;
5873 emit_if_goto (&(aentry
->from_offset
), &(aentry
->from_size
));
5876 case gdb_agent_op_goto
:
5877 arg
= aexpr
->bytes
[pc
++];
5878 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
5879 aentry
->goto_pc
= arg
;
5880 emit_goto (&(aentry
->from_offset
), &(aentry
->from_size
));
5883 case gdb_agent_op_const8
:
5884 emit_stack_flush ();
5885 top
= aexpr
->bytes
[pc
++];
5889 case gdb_agent_op_const16
:
5890 emit_stack_flush ();
5891 top
= aexpr
->bytes
[pc
++];
5892 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5896 case gdb_agent_op_const32
:
5897 emit_stack_flush ();
5898 top
= aexpr
->bytes
[pc
++];
5899 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5900 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5901 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5905 case gdb_agent_op_const64
:
5906 emit_stack_flush ();
5907 top
= aexpr
->bytes
[pc
++];
5908 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5909 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5910 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5911 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5912 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5913 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5914 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
5918 case gdb_agent_op_reg
:
5919 emit_stack_flush ();
5920 arg
= aexpr
->bytes
[pc
++];
5921 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
5925 case gdb_agent_op_end
:
5926 trace_debug ("At end of expression\n");
5928 /* Assume there is one stack element left, and that it is
5929 cached in "top" where emit_epilogue can get to it. */
5930 emit_stack_adjust (1);
5935 case gdb_agent_op_dup
:
5936 /* In our design, dup is equivalent to stack flushing. */
5937 emit_stack_flush ();
5940 case gdb_agent_op_pop
:
5944 case gdb_agent_op_zero_ext
:
5945 arg
= aexpr
->bytes
[pc
++];
5946 if (arg
< (sizeof (LONGEST
) * 8))
5947 emit_zero_ext (arg
);
5950 case gdb_agent_op_swap
:
5954 case gdb_agent_op_getv
:
5955 emit_stack_flush ();
5956 arg
= aexpr
->bytes
[pc
++];
5957 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
5958 emit_int_call_1 (ipa_sym_addrs
.addr_get_trace_state_variable_value
,
5962 case gdb_agent_op_setv
:
5963 arg
= aexpr
->bytes
[pc
++];
5964 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
5965 emit_void_call_2 (ipa_sym_addrs
.addr_set_trace_state_variable_value
,
5969 case gdb_agent_op_tracev
:
5973 /* GDB never (currently) generates any of these ops. */
5974 case gdb_agent_op_float
:
5975 case gdb_agent_op_ref_float
:
5976 case gdb_agent_op_ref_double
:
5977 case gdb_agent_op_ref_long_double
:
5978 case gdb_agent_op_l_to_d
:
5979 case gdb_agent_op_d_to_l
:
5980 case gdb_agent_op_trace16
:
5985 trace_debug ("Agent expression op 0x%x not recognized\n", op
);
5986 /* Don't struggle on, things will just get worse. */
5987 return expr_eval_unrecognized_opcode
;
5990 /* This catches errors that occur in target-specific code
5994 trace_debug ("Error %d while emitting code for %s\n",
5995 emit_error
, gdb_agent_op_name (op
));
5996 return expr_eval_unhandled_opcode
;
5999 trace_debug ("Op %s compiled\n", gdb_agent_op_name (op
));
6002 /* Now fill in real addresses as goto destinations. */
6003 for (aentry
= bytecode_address_table
; aentry
; aentry
= aentry
->next
)
6007 if (aentry
->goto_pc
< 0)
6010 /* Find the location that we are going to, and call back into
6011 target-specific code to write the actual address or
6013 for (aentry2
= bytecode_address_table
; aentry2
; aentry2
= aentry2
->next
)
6015 if (aentry2
->pc
== aentry
->goto_pc
)
6017 trace_debug ("Want to jump from %s to %s\n",
6018 paddress (aentry
->address
),
6019 paddress (aentry2
->address
));
6020 write_goto_address (aentry
->address
+ aentry
->from_offset
,
6021 aentry2
->address
, aentry
->from_size
);
6027 /* Error out if we didn't find a destination. */
6030 trace_debug ("Destination of goto %d not found\n",
6032 return expr_eval_invalid_goto
;
6036 return expr_eval_no_error
;
6039 /* We'll need to adjust these when we consider bi-arch setups, and big
6043 write_inferior_data_ptr (CORE_ADDR where
, CORE_ADDR ptr
)
6045 return write_inferior_memory (where
,
6046 (unsigned char *) &ptr
, sizeof (void *));
6049 /* The base pointer of the IPA's heap. This is the only memory the
6050 IPA is allowed to use. The IPA should _not_ call the inferior's
6051 `malloc' during operation. That'd be slow, and, most importantly,
6052 it may not be safe. We may be collecting a tracepoint in a signal
6053 handler, for example. */
6054 static CORE_ADDR target_tp_heap
;
6056 /* Allocate at least SIZE bytes of memory from the IPA heap, aligned
6060 target_malloc (ULONGEST size
)
6064 if (target_tp_heap
== 0)
6066 /* We have the pointer *address*, need what it points to. */
6067 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_gdb_tp_heap_buffer
,
6069 fatal ("could get target heap head pointer");
6072 ptr
= target_tp_heap
;
6073 target_tp_heap
+= size
;
6075 /* Pad to 8-byte alignment. */
6076 target_tp_heap
= ((target_tp_heap
+ 7) & ~0x7);
6082 download_agent_expr (struct agent_expr
*expr
)
6084 CORE_ADDR expr_addr
;
6085 CORE_ADDR expr_bytes
;
6087 expr_addr
= target_malloc (sizeof (*expr
));
6088 write_inferior_memory (expr_addr
, (unsigned char *) expr
, sizeof (*expr
));
6090 expr_bytes
= target_malloc (expr
->length
);
6091 write_inferior_data_ptr (expr_addr
+ offsetof (struct agent_expr
, bytes
),
6093 write_inferior_memory (expr_bytes
, expr
->bytes
, expr
->length
);
6098 /* Align V up to N bits. */
6099 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
6102 download_tracepoints (void)
6104 CORE_ADDR tpptr
= 0, prev_tpptr
= 0;
6105 struct tracepoint
*tpoint
;
6107 /* Start out empty. */
6108 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, 0);
6110 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
6112 struct tracepoint target_tracepoint
;
6114 if (tpoint
->type
!= fast_tracepoint
6115 && tpoint
->type
!= static_tracepoint
)
6118 /* Maybe download a compiled condition. */
6119 if (tpoint
->cond
!= NULL
&& target_emit_ops () != NULL
)
6121 CORE_ADDR jentry
, jump_entry
;
6123 jentry
= jump_entry
= get_jump_space_head ();
6125 if (tpoint
->cond
!= NULL
)
6127 /* Pad to 8-byte alignment. (needed?) */
6128 /* Actually this should be left for the target to
6130 jentry
= UALIGN (jentry
, 8);
6132 compile_tracepoint_condition (tpoint
, &jentry
);
6135 /* Pad to 8-byte alignment. */
6136 jentry
= UALIGN (jentry
, 8);
6137 claim_jump_space (jentry
- jump_entry
);
6140 target_tracepoint
= *tpoint
;
6143 tpptr
= target_malloc (sizeof (*tpoint
));
6144 tpoint
->obj_addr_on_target
= tpptr
;
6146 if (tpoint
== tracepoints
)
6148 /* First object in list, set the head pointer in the
6150 write_inferior_data_ptr (ipa_sym_addrs
.addr_tracepoints
, tpptr
);
6154 write_inferior_data_ptr (prev_tpptr
+ offsetof (struct tracepoint
,
6159 /* Write the whole object. We'll fix up its pointers in a bit.
6160 Assume no next for now. This is fixed up above on the next
6161 iteration, if there's any. */
6162 target_tracepoint
.next
= NULL
;
6163 /* Need to clear this here too, since we're downloading the
6164 tracepoints before clearing our own copy. */
6165 target_tracepoint
.hit_count
= 0;
6167 write_inferior_memory (tpptr
, (unsigned char *) &target_tracepoint
,
6168 sizeof (target_tracepoint
));
6171 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6173 download_agent_expr (tpoint
->cond
));
6175 if (tpoint
->numactions
)
6178 CORE_ADDR actions_array
;
6180 /* The pointers array. */
6182 = target_malloc (sizeof (*tpoint
->actions
) * tpoint
->numactions
);
6183 write_inferior_data_ptr (tpptr
+ offsetof (struct tracepoint
,
6187 /* Now for each pointer, download the action. */
6188 for (i
= 0; i
< tpoint
->numactions
; i
++)
6190 CORE_ADDR ipa_action
= 0;
6191 struct tracepoint_action
*action
= tpoint
->actions
[i
];
6193 switch (action
->type
)
6197 = target_malloc (sizeof (struct collect_memory_action
));
6198 write_inferior_memory (ipa_action
,
6199 (unsigned char *) action
,
6200 sizeof (struct collect_memory_action
));
6204 = target_malloc (sizeof (struct collect_registers_action
));
6205 write_inferior_memory (ipa_action
,
6206 (unsigned char *) action
,
6207 sizeof (struct collect_registers_action
));
6212 struct eval_expr_action
*eaction
6213 = (struct eval_expr_action
*) action
;
6215 ipa_action
= target_malloc (sizeof (*eaction
));
6216 write_inferior_memory (ipa_action
,
6217 (unsigned char *) eaction
,
6220 expr
= download_agent_expr (eaction
->expr
);
6221 write_inferior_data_ptr
6222 (ipa_action
+ offsetof (struct eval_expr_action
, expr
),
6227 ipa_action
= target_malloc
6228 (sizeof (struct collect_static_trace_data_action
));
6229 write_inferior_memory
6231 (unsigned char *) action
,
6232 sizeof (struct collect_static_trace_data_action
));
6235 trace_debug ("unknown trace action '%c', ignoring",
6240 if (ipa_action
!= 0)
6241 write_inferior_data_ptr
6242 (actions_array
+ i
* sizeof (sizeof (*tpoint
->actions
)),
6250 download_trace_state_variables (void)
6252 CORE_ADDR ptr
= 0, prev_ptr
= 0;
6253 struct trace_state_variable
*tsv
;
6255 /* Start out empty. */
6256 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
, 0);
6258 for (tsv
= trace_state_variables
; tsv
!= NULL
; tsv
= tsv
->next
)
6260 struct trace_state_variable target_tsv
;
6262 /* TSV's with a getter have been initialized equally in both the
6263 inferior and GDBserver. Skip them. */
6264 if (tsv
->getter
!= NULL
)
6270 ptr
= target_malloc (sizeof (*tsv
));
6272 if (tsv
== trace_state_variables
)
6274 /* First object in list, set the head pointer in the
6277 write_inferior_data_ptr (ipa_sym_addrs
.addr_trace_state_variables
,
6282 write_inferior_data_ptr (prev_ptr
6283 + offsetof (struct trace_state_variable
,
6288 /* Write the whole object. We'll fix up its pointers in a bit.
6289 Assume no next, fixup when needed. */
6290 target_tsv
.next
= NULL
;
6292 write_inferior_memory (ptr
, (unsigned char *) &target_tsv
,
6293 sizeof (target_tsv
));
6295 if (tsv
->name
!= NULL
)
6297 size_t size
= strlen (tsv
->name
) + 1;
6298 CORE_ADDR name_addr
= target_malloc (size
);
6299 write_inferior_memory (name_addr
,
6300 (unsigned char *) tsv
->name
, size
);
6301 write_inferior_data_ptr (ptr
6302 + offsetof (struct trace_state_variable
,
6307 if (tsv
->getter
!= NULL
)
6309 fatal ("what to do with these?");
6315 /* Fixup the next pointer in the last item in the list. */
6316 write_inferior_data_ptr (prev_ptr
6317 + offsetof (struct trace_state_variable
,
6322 /* Upload complete trace frames out of the IP Agent's trace buffer
6323 into GDBserver's trace buffer. This always uploads either all or
6324 no trace frames. This is the counter part of
6325 `trace_alloc_trace_buffer'. See its description of the atomic
6326 synching mechanism. */
6329 upload_fast_traceframes (void)
6331 unsigned int ipa_traceframe_read_count
, ipa_traceframe_write_count
;
6332 unsigned int ipa_traceframe_read_count_racy
, ipa_traceframe_write_count_racy
;
6334 struct ipa_trace_buffer_control ipa_trace_buffer_ctrl
;
6335 unsigned int curr_tbctrl_idx
;
6336 unsigned int ipa_trace_buffer_ctrl_curr
;
6337 unsigned int ipa_trace_buffer_ctrl_curr_old
;
6338 CORE_ADDR ipa_trace_buffer_ctrl_addr
;
6339 struct breakpoint
*about_to_request_buffer_space_bkpt
;
6340 CORE_ADDR ipa_trace_buffer_lo
;
6341 CORE_ADDR ipa_trace_buffer_hi
;
6343 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6344 &ipa_traceframe_read_count_racy
))
6346 /* This will happen in most targets if the current thread is
6351 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6352 &ipa_traceframe_write_count_racy
))
6355 trace_debug ("ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6356 ipa_traceframe_write_count_racy
6357 - ipa_traceframe_read_count_racy
,
6358 ipa_traceframe_write_count_racy
,
6359 ipa_traceframe_read_count_racy
);
6361 if (ipa_traceframe_write_count_racy
== ipa_traceframe_read_count_racy
)
6364 about_to_request_buffer_space_bkpt
6365 = set_breakpoint_at (ipa_sym_addrs
.addr_about_to_request_buffer_space
,
6368 if (read_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6369 &ipa_trace_buffer_ctrl_curr
))
6372 ipa_trace_buffer_ctrl_curr_old
= ipa_trace_buffer_ctrl_curr
;
6374 curr_tbctrl_idx
= ipa_trace_buffer_ctrl_curr
& ~GDBSERVER_FLUSH_COUNT_MASK
;
6377 unsigned int prev
, counter
;
6379 /* Update the token, with new counters, and the GDBserver stamp
6380 bit. Alway reuse the current TBC index. */
6381 prev
= ipa_trace_buffer_ctrl_curr
& 0x0007ff00;
6382 counter
= (prev
+ 0x100) & 0x0007ff00;
6384 ipa_trace_buffer_ctrl_curr
= (0x80000000
6390 if (write_inferior_uinteger (ipa_sym_addrs
.addr_trace_buffer_ctrl_curr
,
6391 ipa_trace_buffer_ctrl_curr
))
6394 trace_debug ("Lib: Committed %08x -> %08x",
6395 ipa_trace_buffer_ctrl_curr_old
,
6396 ipa_trace_buffer_ctrl_curr
);
6398 /* Re-read these, now that we've installed the
6399 `about_to_request_buffer_space' breakpoint/lock. A thread could
6400 have finished a traceframe between the last read of these
6401 counters and setting the breakpoint above. If we start
6402 uploading, we never want to leave this function with
6403 traceframe_read_count != 0, otherwise, GDBserver could end up
6404 incrementing the counter tokens more than once (due to event loop
6405 nesting), which would break the IP agent's "effective" detection
6406 (see trace_alloc_trace_buffer). */
6407 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_read_count
,
6408 &ipa_traceframe_read_count
))
6410 if (read_inferior_uinteger (ipa_sym_addrs
.addr_traceframe_write_count
,
6411 &ipa_traceframe_write_count
))
6416 trace_debug ("ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6417 ipa_traceframe_write_count
- ipa_traceframe_read_count
,
6418 ipa_traceframe_write_count
, ipa_traceframe_read_count
);
6420 if (ipa_traceframe_write_count
!= ipa_traceframe_write_count_racy
6421 || ipa_traceframe_read_count
!= ipa_traceframe_read_count_racy
)
6422 trace_debug ("note that ipa_traceframe_count's parts changed");
6425 /* Get the address of the current TBC object (the IP agent has an
6426 array of 3 such objects). The index is stored in the TBC
6428 ipa_trace_buffer_ctrl_addr
= ipa_sym_addrs
.addr_trace_buffer_ctrl
;
6429 ipa_trace_buffer_ctrl_addr
6430 += sizeof (struct ipa_trace_buffer_control
) * curr_tbctrl_idx
;
6432 if (read_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6433 (unsigned char *) &ipa_trace_buffer_ctrl
,
6434 sizeof (struct ipa_trace_buffer_control
)))
6437 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_lo
,
6438 &ipa_trace_buffer_lo
))
6440 if (read_inferior_data_pointer (ipa_sym_addrs
.addr_trace_buffer_hi
,
6441 &ipa_trace_buffer_hi
))
6444 /* Offsets are easier to grok for debugging than raw addresses,
6445 especially for the small trace buffer sizes that are useful for
6447 trace_debug ("Lib: Trace buffer [%d] start=%d free=%d "
6448 "endfree=%d wrap=%d hi=%d",
6450 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6451 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6452 (int) (ipa_trace_buffer_ctrl
.end_free
- ipa_trace_buffer_lo
),
6453 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6454 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6456 /* Note that the IPA's buffer is always circular. */
6458 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6460 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6461 ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6463 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6464 (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6465 - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6466 ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6469 tf
= IPA_FIRST_TRACEFRAME ();
6471 while (ipa_traceframe_write_count
- ipa_traceframe_read_count
)
6473 struct tracepoint
*tpoint
;
6474 struct traceframe
*tframe
;
6475 unsigned char *block
;
6476 struct traceframe ipa_tframe
;
6478 if (read_inferior_memory (tf
, (unsigned char *) &ipa_tframe
,
6479 offsetof (struct traceframe
, data
)))
6480 error ("Uploading: couldn't read traceframe at %s\n", paddress (tf
));
6482 if (ipa_tframe
.tpnum
== 0)
6483 fatal ("Uploading: No (more) fast traceframes, but "
6484 "ipa_traceframe_count == %u??\n",
6485 ipa_traceframe_write_count
- ipa_traceframe_read_count
);
6487 /* Note that this will be incorrect for multi-location
6489 tpoint
= find_next_tracepoint_by_number (NULL
, ipa_tframe
.tpnum
);
6491 tframe
= add_traceframe (tpoint
);
6494 trace_buffer_is_full
= 1;
6495 trace_debug ("Uploading: trace buffer is full");
6499 /* Copy the whole set of blocks in one go for now. FIXME:
6500 split this in smaller blocks. */
6501 block
= add_traceframe_block (tframe
, ipa_tframe
.data_size
);
6504 if (read_inferior_memory (tf
6505 + offsetof (struct traceframe
, data
),
6506 block
, ipa_tframe
.data_size
))
6507 error ("Uploading: Couldn't read traceframe data at %s\n",
6508 paddress (tf
+ offsetof (struct traceframe
, data
)));
6511 trace_debug ("Uploading: traceframe didn't fit");
6512 finish_traceframe (tframe
);
6515 tf
= IPA_NEXT_TRACEFRAME (tf
, &ipa_tframe
);
6517 /* If we freed the traceframe that wrapped around, go back
6518 to the non-wrap case. */
6519 if (tf
< ipa_trace_buffer_ctrl
.start
)
6521 trace_debug ("Lib: Discarding past the wraparound");
6522 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6524 ipa_trace_buffer_ctrl
.start
= tf
;
6525 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_ctrl
.start
;
6526 ++ipa_traceframe_read_count
;
6528 if (ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.free
6529 && ipa_trace_buffer_ctrl
.start
== ipa_trace_buffer_ctrl
.end_free
)
6531 trace_debug ("Lib: buffer is fully empty. "
6532 "Trace buffer [%d] start=%d free=%d endfree=%d",
6534 (int) (ipa_trace_buffer_ctrl
.start
6535 - ipa_trace_buffer_lo
),
6536 (int) (ipa_trace_buffer_ctrl
.free
6537 - ipa_trace_buffer_lo
),
6538 (int) (ipa_trace_buffer_ctrl
.end_free
6539 - ipa_trace_buffer_lo
));
6541 ipa_trace_buffer_ctrl
.start
= ipa_trace_buffer_lo
;
6542 ipa_trace_buffer_ctrl
.free
= ipa_trace_buffer_lo
;
6543 ipa_trace_buffer_ctrl
.end_free
= ipa_trace_buffer_hi
;
6544 ipa_trace_buffer_ctrl
.wrap
= ipa_trace_buffer_hi
;
6547 trace_debug ("Uploaded a traceframe\n"
6548 "Lib: Trace buffer [%d] start=%d free=%d "
6549 "endfree=%d wrap=%d hi=%d",
6551 (int) (ipa_trace_buffer_ctrl
.start
- ipa_trace_buffer_lo
),
6552 (int) (ipa_trace_buffer_ctrl
.free
- ipa_trace_buffer_lo
),
6553 (int) (ipa_trace_buffer_ctrl
.end_free
6554 - ipa_trace_buffer_lo
),
6555 (int) (ipa_trace_buffer_ctrl
.wrap
- ipa_trace_buffer_lo
),
6556 (int) (ipa_trace_buffer_hi
- ipa_trace_buffer_lo
));
6559 if (write_inferior_memory (ipa_trace_buffer_ctrl_addr
,
6560 (unsigned char *) &ipa_trace_buffer_ctrl
,
6561 sizeof (struct ipa_trace_buffer_control
)))
6564 write_inferior_integer (ipa_sym_addrs
.addr_traceframe_read_count
,
6565 ipa_traceframe_read_count
);
6567 trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx
);
6570 cancel_breakpoints ();
6572 delete_breakpoint (about_to_request_buffer_space_bkpt
);
6573 about_to_request_buffer_space_bkpt
= NULL
;
6577 if (trace_buffer_is_full
)
6582 #ifdef IN_PROCESS_AGENT
6584 IP_AGENT_EXPORT
int ust_loaded
;
6585 IP_AGENT_EXPORT
char cmd_buf
[CMD_BUF_SIZE
];
6589 /* Static tracepoints. */
6591 /* UST puts a "struct tracepoint" in the global namespace, which
6592 conflicts with our tracepoint. Arguably, being a library, it
6593 shouldn't take ownership of such a generic name. We work around it
6595 #define tracepoint ust_tracepoint
6596 #include <ust/ust.h>
6599 extern int serialize_to_text (char *outbuf
, int bufsize
,
6600 const char *fmt
, va_list ap
);
6602 #define GDB_PROBE_NAME "gdb"
6604 /* We dynamically search for the UST symbols instead of linking them
6605 in. This lets the user decide if the application uses static
6606 tracepoints, instead of always pulling libust.so in. This vector
6607 holds pointers to all functions we care about. */
6611 int (*serialize_to_text
) (char *outbuf
, int bufsize
,
6612 const char *fmt
, va_list ap
);
6614 int (*ltt_probe_register
) (struct ltt_available_probe
*pdata
);
6615 int (*ltt_probe_unregister
) (struct ltt_available_probe
*pdata
);
6617 int (*ltt_marker_connect
) (const char *channel
, const char *mname
,
6619 int (*ltt_marker_disconnect
) (const char *channel
, const char *mname
,
6622 void (*marker_iter_start
) (struct marker_iter
*iter
);
6623 void (*marker_iter_next
) (struct marker_iter
*iter
);
6624 void (*marker_iter_stop
) (struct marker_iter
*iter
);
6625 void (*marker_iter_reset
) (struct marker_iter
*iter
);
6630 /* Cast through typeof to catch incompatible API changes. Since UST
6631 only builds with gcc, we can freely use gcc extensions here
6633 #define GET_UST_SYM(SYM) \
6636 if (ust_ops.SYM == NULL) \
6637 ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6638 if (ust_ops.SYM == NULL) \
6642 #define USTF(SYM) ust_ops.SYM
6644 /* Get pointers to all libust.so functions we care about. */
6649 GET_UST_SYM (serialize_to_text
);
6651 GET_UST_SYM (ltt_probe_register
);
6652 GET_UST_SYM (ltt_probe_unregister
);
6653 GET_UST_SYM (ltt_marker_connect
);
6654 GET_UST_SYM (ltt_marker_disconnect
);
6656 GET_UST_SYM (marker_iter_start
);
6657 GET_UST_SYM (marker_iter_next
);
6658 GET_UST_SYM (marker_iter_stop
);
6659 GET_UST_SYM (marker_iter_reset
);
6665 /* Given an UST marker, return the matching gdb static tracepoint.
6666 The match is done by address. */
6668 static struct tracepoint
*
6669 ust_marker_to_static_tracepoint (const struct marker
*mdata
)
6671 struct tracepoint
*tpoint
;
6673 for (tpoint
= tracepoints
; tpoint
; tpoint
= tpoint
->next
)
6675 if (tpoint
->type
!= static_tracepoint
)
6678 if (tpoint
->address
== (uintptr_t) mdata
->location
)
6685 /* The probe function we install on lttng/ust markers. Whenever a
6686 probed ust marker is hit, this function is called. This is similar
6687 to gdb_collect, only for static tracepoints, instead of fast
6691 gdb_probe (const struct marker
*mdata
, void *probe_private
,
6692 struct registers
*regs
, void *call_private
,
6693 const char *fmt
, va_list *args
)
6695 struct tracepoint
*tpoint
;
6696 struct static_tracepoint_ctx ctx
;
6698 /* Don't do anything until the trace run is completely set up. */
6701 trace_debug ("gdb_probe: not tracing\n");
6705 ctx
.base
.type
= static_tracepoint
;
6706 ctx
.regcache_initted
= 0;
6711 /* Wrap the regblock in a register cache (in the stack, we don't
6712 want to malloc here). */
6713 ctx
.regspace
= alloca (register_cache_size ());
6714 if (ctx
.regspace
== NULL
)
6716 trace_debug ("Trace buffer block allocation failed, skipping");
6720 tpoint
= ust_marker_to_static_tracepoint (mdata
);
6723 trace_debug ("gdb_probe: marker not known: "
6724 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6725 mdata
->location
, mdata
->channel
,
6726 mdata
->name
, mdata
->format
);
6730 if (!tpoint
->enabled
)
6732 trace_debug ("gdb_probe: tracepoint disabled");
6736 ctx
.tpoint
= tpoint
;
6738 trace_debug ("gdb_probe: collecting marker: "
6739 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6740 mdata
->location
, mdata
->channel
,
6741 mdata
->name
, mdata
->format
);
6743 /* Test the condition if present, and collect if true. */
6744 if (tpoint
->cond
== NULL
6745 || condition_true_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6748 collect_data_at_tracepoint ((struct tracepoint_hit_ctx
*) &ctx
,
6749 tpoint
->address
, tpoint
);
6751 if (stopping_tracepoint
6752 || trace_buffer_is_full
6753 || expr_eval_result
!= expr_eval_no_error
)
6758 /* If there was a condition and it evaluated to false, the only
6759 way we would stop tracing is if there was an error during
6760 condition expression evaluation. */
6761 if (expr_eval_result
!= expr_eval_no_error
)
6766 /* Called if the gdb static tracepoint requested collecting "$_sdata",
6767 static tracepoint string data. This is a string passed to the
6768 tracing library by the user, at the time of the tracepoint marker
6769 call. E.g., in the UST marker call:
6771 trace_mark (ust, bar33, "str %s", "FOOBAZ");
6773 the collected data is "str FOOBAZ".
6777 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx
*ctx
,
6779 struct tracepoint
*tpoint
,
6780 struct traceframe
*tframe
)
6782 struct static_tracepoint_ctx
*umd
= (struct static_tracepoint_ctx
*) ctx
;
6783 unsigned char *bufspace
;
6786 unsigned short blocklen
;
6790 trace_debug ("Wanted to collect static trace data, "
6791 "but there's no static trace data");
6795 va_copy (copy
, *umd
->args
);
6796 size
= USTF(serialize_to_text
) (NULL
, 0, umd
->fmt
, copy
);
6799 trace_debug ("Want to collect ust data");
6801 /* 'S' + size + string */
6802 bufspace
= add_traceframe_block (tframe
,
6803 1 + sizeof (blocklen
) + size
+ 1);
6804 if (bufspace
== NULL
)
6806 trace_debug ("Trace buffer block allocation failed, skipping");
6810 /* Identify a static trace data block. */
6813 blocklen
= size
+ 1;
6814 memcpy (bufspace
+ 1, &blocklen
, sizeof (blocklen
));
6816 va_copy (copy
, *umd
->args
);
6817 USTF(serialize_to_text
) ((char *) bufspace
+ 1 + sizeof (blocklen
),
6818 size
+ 1, umd
->fmt
, copy
);
6821 trace_debug ("Storing static tracepoint data in regblock: %s",
6822 bufspace
+ 1 + sizeof (blocklen
));
6825 /* The probe to register with lttng/ust. */
6826 static struct ltt_available_probe gdb_ust_probe
=
6833 #endif /* HAVE_UST */
6834 #endif /* IN_PROCESS_AGENT */
6838 #include <sys/socket.h>
6841 #ifndef UNIX_PATH_MAX
6842 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6845 /* Where we put the socked used for synchronization. */
6846 #define SOCK_DIR P_tmpdir
6848 #endif /* HAVE_UST */
6850 #ifndef IN_PROCESS_AGENT
6855 gdb_ust_connect_sync_socket (int pid
)
6857 struct sockaddr_un addr
;
6859 char path
[UNIX_PATH_MAX
];
6861 res
= xsnprintf (path
, UNIX_PATH_MAX
, "%s/gdb_ust%d", SOCK_DIR
, pid
);
6862 if (res
>= UNIX_PATH_MAX
)
6864 trace_debug ("string overflow allocating socket name");
6868 res
= fd
= socket (PF_UNIX
, SOCK_STREAM
, 0);
6871 warning ("error opening sync socket: %s\n", strerror (errno
));
6875 addr
.sun_family
= AF_UNIX
;
6877 res
= xsnprintf (addr
.sun_path
, UNIX_PATH_MAX
, "%s", path
);
6878 if (res
>= UNIX_PATH_MAX
)
6880 warning ("string overflow allocating socket name\n");
6885 res
= connect (fd
, (struct sockaddr
*) &addr
, sizeof (addr
));
6888 warning ("error connecting sync socket (%s): %s. "
6889 "Make sure the directory exists and that it is writable.",
6890 path
, strerror (errno
));
6898 /* Resume thread PTID. */
6901 resume_thread (ptid_t ptid
)
6903 struct thread_resume resume_info
;
6905 resume_info
.thread
= ptid
;
6906 resume_info
.kind
= resume_continue
;
6907 resume_info
.sig
= TARGET_SIGNAL_0
;
6908 (*the_target
->resume
) (&resume_info
, 1);
6911 /* Stop thread PTID. */
6914 stop_thread (ptid_t ptid
)
6916 struct thread_resume resume_info
;
6918 resume_info
.thread
= ptid
;
6919 resume_info
.kind
= resume_stop
;
6920 resume_info
.sig
= TARGET_SIGNAL_0
;
6921 (*the_target
->resume
) (&resume_info
, 1);
6924 /* Ask the in-process agent to run a command. Since we don't want to
6925 have to handle the IPA hitting breakpoints while running the
6926 command, we pause all threads, remove all breakpoints, and then set
6927 the helper thread re-running. We communicate with the helper
6928 thread by means of direct memory xfering, and a socket for
6932 run_inferior_command (char *cmd
)
6936 int pid
= ptid_get_pid (current_inferior
->entry
.id
);
6938 ptid_t ptid
= null_ptid
;
6940 trace_debug ("run_inferior_command: running: %s", cmd
);
6943 uninsert_all_breakpoints ();
6945 if (read_inferior_integer (ipa_sym_addrs
.addr_helper_thread_id
, &tid
))
6947 warning ("Error reading helper thread's id in lib");
6953 warning ("helper thread not initialized yet");
6957 if (write_inferior_memory (ipa_sym_addrs
.addr_cmd_buf
,
6958 (unsigned char *) cmd
, strlen (cmd
) + 1))
6960 warning ("Error writing command");
6964 ptid
= ptid_build (pid
, tid
, 0);
6966 resume_thread (ptid
);
6968 fd
= gdb_ust_connect_sync_socket (pid
);
6974 trace_debug ("signalling helper thread");
6978 ret
= write (fd
, buf
, 1);
6979 } while (ret
== -1 && errno
== EINTR
);
6981 trace_debug ("waiting for helper thread's response");
6985 ret
= read (fd
, buf
, 1);
6986 } while (ret
== -1 && errno
== EINTR
);
6990 trace_debug ("helper thread's response received");
6995 /* Need to read response with the inferior stopped. */
6996 if (!ptid_equal (ptid
, null_ptid
))
6998 int was_non_stop
= non_stop
;
6999 struct target_waitstatus status
;
7003 mywait (ptid
, &status
, 0, 0);
7004 non_stop
= was_non_stop
;
7009 if (read_inferior_memory (ipa_sym_addrs
.addr_cmd_buf
,
7010 (unsigned char *) cmd
, CMD_BUF_SIZE
))
7012 warning ("Error reading command response");
7017 trace_debug ("run_inferior_command: response: %s", cmd
);
7021 reinsert_all_breakpoints ();
7027 #else /* HAVE_UST */
7030 run_inferior_command (char *cmd
)
7035 #endif /* HAVE_UST */
7037 #else /* !IN_PROCESS_AGENT */
7039 /* Thread ID of the helper thread. GDBserver reads this to know which
7040 is the help thread. This is an LWP id on Linux. */
7041 int helper_thread_id
;
7046 init_named_socket (const char *name
)
7049 struct sockaddr_un addr
;
7051 result
= fd
= socket (PF_UNIX
, SOCK_STREAM
, 0);
7054 warning ("socket creation failed: %s", strerror (errno
));
7058 addr
.sun_family
= AF_UNIX
;
7060 strncpy (addr
.sun_path
, name
, UNIX_PATH_MAX
);
7061 addr
.sun_path
[UNIX_PATH_MAX
- 1] = '\0';
7063 result
= access (name
, F_OK
);
7067 result
= unlink (name
);
7070 warning ("unlink failed: %s", strerror (errno
));
7074 warning ("socket %s already exists; overwriting", name
);
7077 result
= bind (fd
, (struct sockaddr
*) &addr
, sizeof (addr
));
7080 warning ("bind failed: %s", strerror (errno
));
7085 result
= listen (fd
, 1);
7088 warning ("listen: %s", strerror (errno
));
7097 gdb_ust_socket_init (void)
7100 char name
[UNIX_PATH_MAX
];
7102 result
= xsnprintf (name
, UNIX_PATH_MAX
, "%s/gdb_ust%d",
7103 SOCK_DIR
, getpid ());
7104 if (result
>= UNIX_PATH_MAX
)
7106 trace_debug ("string overflow allocating socket name");
7110 fd
= init_named_socket (name
);
7112 warning ("Error initializing named socket (%s) for communication with the "
7113 "ust helper thread. Check that directory exists and that it "
7114 "is writable.", name
);
7119 /* Return an hexstr version of the STR C string, fit for sending to
7123 cstr_to_hexstr (const char *str
)
7125 int len
= strlen (str
);
7126 char *hexstr
= xmalloc (len
* 2 + 1);
7127 convert_int_to_ascii ((gdb_byte
*) str
, hexstr
, len
);
7131 /* The next marker to be returned on a qTsSTM command. */
7132 static const struct marker
*next_st
;
7134 /* Returns the first known marker. */
7139 struct marker_iter iter
;
7141 USTF(marker_iter_reset
) (&iter
);
7142 USTF(marker_iter_start
) (&iter
);
7147 /* Returns the marker following M. */
7149 const struct marker
*
7150 next_marker (const struct marker
*m
)
7152 struct marker_iter iter
;
7154 USTF(marker_iter_reset
) (&iter
);
7155 USTF(marker_iter_start
) (&iter
);
7157 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
7159 if (iter
.marker
== m
)
7161 USTF(marker_iter_next
) (&iter
);
7169 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
7173 response_ust_marker (char *packet
, const struct marker
*st
)
7175 char *strid
, *format
, *tmp
;
7177 next_st
= next_marker (st
);
7179 tmp
= xmalloc (strlen (st
->channel
) + 1 +
7180 strlen (st
->name
) + 1);
7181 sprintf (tmp
, "%s/%s", st
->channel
, st
->name
);
7183 strid
= cstr_to_hexstr (tmp
);
7186 format
= cstr_to_hexstr (st
->format
);
7188 sprintf (packet
, "m%s:%s:%s",
7189 paddress ((uintptr_t) st
->location
),
7197 /* Return the first static tracepoint, and initialize the state
7198 machine that will iterate through all the static tracepoints. */
7201 cmd_qtfstm (char *packet
)
7203 trace_debug ("Returning first trace state variable definition");
7205 if (first_marker ())
7206 response_ust_marker (packet
, first_marker ());
7208 strcpy (packet
, "l");
7211 /* Return additional trace state variable definitions. */
7214 cmd_qtsstm (char *packet
)
7216 trace_debug ("Returning static tracepoint");
7219 response_ust_marker (packet
, next_st
);
7221 strcpy (packet
, "l");
7224 /* Disconnect the GDB probe from a marker at a given address. */
7227 unprobe_marker_at (char *packet
)
7231 struct marker_iter iter
;
7233 p
+= sizeof ("unprobe_marker_at:") - 1;
7235 p
= unpack_varlen_hex (p
, &address
);
7237 USTF(marker_iter_reset
) (&iter
);
7238 USTF(marker_iter_start
) (&iter
);
7239 for (; iter
.marker
!= NULL
; USTF(marker_iter_next
) (&iter
))
7240 if ((uintptr_t ) iter
.marker
->location
== address
)
7244 result
= USTF(ltt_marker_disconnect
) (iter
.marker
->channel
,
7248 warning ("could not disable marker %s/%s",
7249 iter
.marker
->channel
, iter
.marker
->name
);
7254 /* Connect the GDB probe to a marker at a given address. */
7257 probe_marker_at (char *packet
)
7261 struct marker_iter iter
;
7264 p
+= sizeof ("probe_marker_at:") - 1;
7266 p
= unpack_varlen_hex (p
, &address
);
7268 USTF(marker_iter_reset
) (&iter
);
7270 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7272 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7273 if ((uintptr_t ) m
->location
== address
)
7277 trace_debug ("found marker for address. "
7278 "ltt_marker_connect (marker = %s/%s)",
7279 m
->channel
, m
->name
);
7281 result
= USTF(ltt_marker_connect
) (m
->channel
, m
->name
,
7283 if (result
&& result
!= -EEXIST
)
7284 trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
7285 m
->channel
, m
->name
, -result
);
7289 sprintf (packet
, "E.could not connect marker: channel=%s, name=%s",
7290 m
->channel
, m
->name
);
7294 strcpy (packet
, "OK");
7298 sprintf (packet
, "E.no marker found at 0x%s", paddress (address
));
7303 cmd_qtstmat (char *packet
)
7307 struct marker_iter iter
;
7310 p
+= sizeof ("qTSTMat:") - 1;
7312 p
= unpack_varlen_hex (p
, &address
);
7314 USTF(marker_iter_reset
) (&iter
);
7316 for (USTF(marker_iter_start
) (&iter
), m
= iter
.marker
;
7318 USTF(marker_iter_next
) (&iter
), m
= iter
.marker
)
7319 if ((uintptr_t ) m
->location
== address
)
7321 response_ust_marker (packet
, m
);
7325 strcpy (packet
, "l");
7330 gdb_ust_thread (void *arg
)
7336 listen_fd
= gdb_ust_socket_init ();
7339 if (helper_thread_id
== 0)
7340 helper_thread_id
= syscall (SYS_gettid
);
7343 if (listen_fd
== -1)
7345 warning ("could not create sync socket\n");
7352 struct sockaddr_un sockaddr
;
7357 tmp
= sizeof (sockaddr
);
7361 fd
= accept (listen_fd
, &sockaddr
, &tmp
);
7363 /* It seems an ERESTARTSYS can escape out of accept. */
7364 while (fd
== -512 || (fd
== -1 && errno
== EINTR
));
7368 warning ("Accept returned %d, error: %s\n",
7369 fd
, strerror (errno
));
7375 ret
= read (fd
, buf
, 1);
7376 } while (ret
== -1 && errno
== EINTR
);
7380 warning ("reading socket (fd=%d) failed with %s",
7381 fd
, strerror (errno
));
7388 if (strcmp ("qTfSTM", cmd_buf
) == 0)
7390 cmd_qtfstm (cmd_buf
);
7392 else if (strcmp ("qTsSTM", cmd_buf
) == 0)
7394 cmd_qtsstm (cmd_buf
);
7396 else if (strncmp ("unprobe_marker_at:",
7398 sizeof ("unprobe_marker_at:") - 1) == 0)
7400 unprobe_marker_at (cmd_buf
);
7402 else if (strncmp ("probe_marker_at:",
7404 sizeof ("probe_marker_at:") - 1) == 0)
7406 probe_marker_at (cmd_buf
);
7408 else if (strncmp ("qTSTMat:",
7410 sizeof ("qTSTMat:") - 1) == 0)
7412 cmd_qtstmat (cmd_buf
);
7414 else if (strcmp (cmd_buf
, "help") == 0)
7416 strcpy (cmd_buf
, "for help, press F1\n");
7419 strcpy (cmd_buf
, "");
7443 /* We want the helper thread to be as transparent as possible, so
7444 have it inherit an all-signals-blocked mask. */
7446 sigfillset (&new_mask
);
7447 res
= pthread_sigmask (SIG_SETMASK
, &new_mask
, &orig_mask
);
7449 fatal ("pthread_sigmask (1) failed: %s", strerror (res
));
7451 res
= pthread_create (&thread
,
7456 res
= pthread_sigmask (SIG_SETMASK
, &orig_mask
, NULL
);
7458 fatal ("pthread_sigmask (2) failed: %s", strerror (res
));
7460 while (helper_thread_id
== 0)
7463 USTF(ltt_probe_register
) (&gdb_ust_probe
);
7466 #endif /* HAVE_UST */
7468 #include <sys/mman.h>
7471 IP_AGENT_EXPORT
char *gdb_tp_heap_buffer
;
7472 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer
;
7473 IP_AGENT_EXPORT
char *gdb_jump_pad_buffer_end
;
7475 static void __attribute__ ((constructor
))
7476 initialize_tracepoint_ftlib (void)
7478 initialize_tracepoint ();
7485 #endif /* IN_PROCESS_AGENT */
7488 tsv_get_timestamp (void)
7492 if (gettimeofday (&tv
, 0) != 0)
7495 return (LONGEST
) tv
.tv_sec
* 1000000 + tv
.tv_usec
;
7499 initialize_tracepoint (void)
7501 /* There currently no way to change the buffer size. */
7502 const int sizeOfBuffer
= 5 * 1024 * 1024;
7503 unsigned char *buf
= xmalloc (sizeOfBuffer
);
7504 init_trace_buffer (buf
, sizeOfBuffer
);
7506 /* Wire trace state variable 1 to be the timestamp. This will be
7507 uploaded to GDB upon connection and become one of its trace state
7508 variables. (In case you're wondering, if GDB already has a trace
7509 variable numbered 1, it will be renumbered.) */
7510 create_trace_state_variable (1, 0);
7511 set_trace_state_variable_name (1, "trace_timestamp");
7512 set_trace_state_variable_getter (1, tsv_get_timestamp
);
7514 #ifdef IN_PROCESS_AGENT
7517 pagesize
= sysconf (_SC_PAGE_SIZE
);
7521 gdb_tp_heap_buffer
= xmalloc (5 * 1024 * 1024);
7523 /* Allocate scratch buffer aligned on a page boundary. */
7524 gdb_jump_pad_buffer
= memalign (pagesize
, pagesize
* 20);
7525 gdb_jump_pad_buffer_end
= gdb_jump_pad_buffer
+ pagesize
* 20;
7527 /* Make it writable and executable. */
7528 if (mprotect (gdb_jump_pad_buffer
, pagesize
* 20,
7529 PROT_READ
| PROT_WRITE
| PROT_EXEC
) != 0)
7531 initialize_tracepoint: mprotect(%p, %d, PROT_READ|PROT_EXEC) failed with %s",
7532 gdb_jump_pad_buffer
, pagesize
* 20, strerror (errno
));
7535 initialize_low_tracepoint ();