33 #define DEFAULT_TRACE_BUFFER_SIZE 5242880
62 #ifdef IN_PROCESS_AGENT
67 trace_vdebug (const
char *fmt, ...)
73 vsprintf (buf, fmt, ap);
74 fprintf (stderr,
PROG "/tracepoint: %s\n", buf);
78 #define trace_debug_1(level, fmt, args...) \
80 if (level <= debug_threads) \
81 trace_vdebug ((fmt), ##args); \
86 #define trace_debug_1(level, fmt, args...) \
88 if (level <= debug_threads) \
90 debug_printf ((fmt), ##args); \
91 debug_printf ("\n"); \
97 #define trace_debug(FMT, args...) \
98 trace_debug_1 (1, FMT, ##args)
103 #ifdef IN_PROCESS_AGENT
104 # define gdb_tp_heap_buffer IPA_SYM_EXPORTED_NAME (gdb_tp_heap_buffer)
105 # define gdb_jump_pad_buffer IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer)
106 # define gdb_jump_pad_buffer_end IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer_end)
107 # define gdb_trampoline_buffer IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer)
108 # define gdb_trampoline_buffer_end IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_end)
109 # define gdb_trampoline_buffer_error IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_error)
110 # define collecting IPA_SYM_EXPORTED_NAME (collecting)
111 # define gdb_collect IPA_SYM_EXPORTED_NAME (gdb_collect)
112 # define stop_tracing IPA_SYM_EXPORTED_NAME (stop_tracing)
113 # define flush_trace_buffer IPA_SYM_EXPORTED_NAME (flush_trace_buffer)
114 # define about_to_request_buffer_space IPA_SYM_EXPORTED_NAME (about_to_request_buffer_space)
115 # define trace_buffer_is_full IPA_SYM_EXPORTED_NAME (trace_buffer_is_full)
116 # define stopping_tracepoint IPA_SYM_EXPORTED_NAME (stopping_tracepoint)
117 # define expr_eval_result IPA_SYM_EXPORTED_NAME (expr_eval_result)
118 # define error_tracepoint IPA_SYM_EXPORTED_NAME (error_tracepoint)
119 # define tracepoints IPA_SYM_EXPORTED_NAME (tracepoints)
120 # define tracing IPA_SYM_EXPORTED_NAME (tracing)
121 # define trace_buffer_ctrl IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl)
122 # define trace_buffer_ctrl_curr IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl_curr)
123 # define trace_buffer_lo IPA_SYM_EXPORTED_NAME (trace_buffer_lo)
124 # define trace_buffer_hi IPA_SYM_EXPORTED_NAME (trace_buffer_hi)
125 # define traceframe_read_count IPA_SYM_EXPORTED_NAME (traceframe_read_count)
126 # define traceframe_write_count IPA_SYM_EXPORTED_NAME (traceframe_write_count)
127 # define traceframes_created IPA_SYM_EXPORTED_NAME (traceframes_created)
128 # define trace_state_variables IPA_SYM_EXPORTED_NAME (trace_state_variables)
129 # define get_raw_reg IPA_SYM_EXPORTED_NAME (get_raw_reg)
130 # define get_trace_state_variable_value \
131 IPA_SYM_EXPORTED_NAME (get_trace_state_variable_value)
132 # define set_trace_state_variable_value \
133 IPA_SYM_EXPORTED_NAME (set_trace_state_variable_value)
134 # define ust_loaded IPA_SYM_EXPORTED_NAME (ust_loaded)
135 # define helper_thread_id IPA_SYM_EXPORTED_NAME (helper_thread_id)
136 # define cmd_buf IPA_SYM_EXPORTED_NAME (cmd_buf)
139 #ifndef IN_PROCESS_AGENT
184 IPA_SYM(gdb_jump_pad_buffer_end),
185 IPA_SYM(gdb_trampoline_buffer),
186 IPA_SYM(gdb_trampoline_buffer_end),
187 IPA_SYM(gdb_trampoline_buffer_error),
192 IPA_SYM(about_to_request_buffer_space),
200 IPA_SYM(trace_buffer_ctrl_curr),
203 IPA_SYM(traceframe_read_count),
204 IPA_SYM(traceframe_write_count),
206 IPA_SYM(trace_state_variables),
228 warning (
"In-process agent not loaded");
238 warning (
"Error reading ust_loaded in lib");
252 "E.In-process agent library not loaded in process. "
253 "Fast and static tracepoints unavailable.");
264 "E.UST library not loaded in process. "
265 "Static tracepoints unavailable.");
267 sprintf (buffer,
"E.GDBserver was built without static tracepoints support");
350 #ifdef IN_PROCESS_AGENT
354 memcpy (myaddr, (
void *) (uintptr_t) memaddr, len);
363 #if defined(__GNUC__)
364 # define UNKNOWN_SIDE_EFFECTS() asm ("")
366 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
373 UNKNOWN_SIDE_EFFECTS();
377 flush_trace_buffer (
void)
380 UNKNOWN_SIDE_EFFECTS();
385 #ifndef IN_PROCESS_AGENT
389 trace_debug (
"tracepoint_handler: tracepoint at 0x%s hit",
427 void *pval = (
void *) (uintptr_t) val;
431 *val = (uintptr_t) pval;
438 void *pval = (
void *) (uintptr_t) val;
440 (
unsigned char *) &pval,
sizeof (pval));
458 #define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
460 memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
461 BUF += sizeof ((OBJ)->FIELD); \
485 #ifndef IN_PROCESS_AGENT
523 #ifndef IN_PROCESS_AGENT
528 - offsetof (struct tracepoint_action, type));
559 - offsetof (struct tracepoint_action, type));
586 - offsetof (struct tracepoint_action, type));
594 - offsetof (
struct tracepoint_action, type),
615 memcpy (p, &aexpr->
length, 4);
642 - offsetof (struct tracepoint_action, type));
758 #ifndef IN_PROCESS_AGENT
809 #ifndef IN_PROCESS_AGENT
856 #ifndef IN_PROCESS_AGENT
863 static const char *eval_result_names[] =
865 "terror:in the attic",
866 "terror:empty expression",
867 "terror:empty stack",
868 "terror:stack overflow",
869 "terror:stack underflow",
870 "terror:unhandled opcode",
871 "terror:unrecognized opcode",
872 "terror:divide by zero"
911 #ifdef IN_PROCESS_AGENT
945 # if defined(__GNUC__)
946 # define ATTR_PACKED __attribute__ ((packed))
979 #define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
984 int current_traceframe = -1;
990 #ifndef IN_PROCESS_AGENT
1150 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1155 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1156 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1160 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1162 #ifdef IN_PROCESS_AGENT
1166 # define TRACE_BUFFER_CTRL_CURR \
1167 (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1176 # define TRACE_BUFFER_CTRL_CURR 0
1181 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1182 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1183 #define trace_buffer_end_free \
1184 (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1185 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1190 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1196 #define NEXT_TRACEFRAME_1(TF) \
1197 (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1199 #define NEXT_TRACEFRAME(TF) \
1200 ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1201 - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1202 ? (trace_buffer_wrap - trace_buffer_lo) \
1214 #define traceframe_count \
1215 ((unsigned int) (traceframe_write_count - traceframe_read_count))
1222 #ifndef IN_PROCESS_AGENT
1252 #ifndef IN_PROCESS_AGENT
1262 static const char *tracing_stop_reason =
"tnotrun";
1298 #ifdef IN_PROCESS_AGENT
1302 struct fast_tracepoint_ctx
1307 int regcache_initted;
1308 unsigned char *regspace;
1310 unsigned char *regs;
1316 struct static_tracepoint_ctx
1323 int regcache_initted;
1328 unsigned char *regspace;
1331 struct registers *regs;
1356 #ifndef IN_PROCESS_AGENT
1364 #ifndef IN_PROCESS_AGENT
1372 #ifndef IN_PROCESS_AGENT
1375 struct tracepoint *tpoint,
int current_step);
1385 #ifndef IN_PROCESS_AGENT
1397 #if defined(__GNUC__)
1398 # define memory_barrier() asm volatile ("" : : : "memory")
1400 # define memory_barrier() do {} while (0)
1406 #define cmpxchg(mem, oldval, newval) \
1407 __sync_val_compare_and_swap (mem, oldval, newval)
1415 trace_debug (
"Tracepoint %d at %s %s eval reports error %d",
1418 #ifdef IN_PROCESS_AGENT
1420 if (
cmpxchg (&expr_eval_result,
1429 error_tracepoint = tpoint;
1444 traceframe_read_count = traceframe_write_count = 0;
1445 traceframes_created = 0;
1448 #ifndef IN_PROCESS_AGENT
1459 &ipa_trace_buffer_lo);
1461 &ipa_trace_buffer_hi);
1463 ipa_trace_buffer_ctrl.
start = ipa_trace_buffer_lo;
1464 ipa_trace_buffer_ctrl.
free = ipa_trace_buffer_lo;
1465 ipa_trace_buffer_ctrl.
end_free = ipa_trace_buffer_hi;
1466 ipa_trace_buffer_ctrl.
wrap = ipa_trace_buffer_hi;
1470 (
unsigned char *) &ipa_trace_buffer_ctrl,
1471 sizeof (ipa_trace_buffer_ctrl));
1477 (
unsigned char *) &ipa_traceframe,
1478 sizeof (ipa_traceframe));
1492 trace_buffer_size = bufsize;
1498 trace_buffer_lo =
xrealloc (trace_buffer_lo, alloc_size);
1505 #ifdef IN_PROCESS_AGENT
1508 about_to_request_buffer_space (
void)
1512 UNKNOWN_SIDE_EFFECTS();
1523 unsigned char *rslt;
1526 #ifdef IN_PROCESS_AGENT
1527 unsigned int prev, prev_filtered;
1528 unsigned int commit_count;
1529 unsigned int commit;
1530 unsigned int readout;
1533 unsigned char *new_start;
1536 trace_debug (
"Want to allocate %ld+%ld bytes in trace buffer",
1537 (
long) amt, (
long)
sizeof (
struct traceframe));
1542 #ifdef IN_PROCESS_AGENT
1548 prev = trace_buffer_ctrl_curr;
1550 curr = prev_filtered + 1;
1554 about_to_request_buffer_space ();
1572 trace_debug (
"Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1574 (
int) (tbctrl->
start - trace_buffer_lo),
1575 (
int) (tbctrl->
free - trace_buffer_lo),
1576 (
int) (tbctrl->
end_free - trace_buffer_lo),
1577 (
int) (tbctrl->
wrap - trace_buffer_lo),
1578 (
int) (trace_buffer_hi - trace_buffer_lo));
1591 if (tbctrl->
free + amt <= trace_buffer_hi)
1600 trace_debug (
"Upper part too small, setting wraparound");
1607 if (tbctrl->
free + amt <= tbctrl->end_free)
1610 #ifdef IN_PROCESS_AGENT
1616 flush_trace_buffer ();
1620 trace_debug (
"gdbserver flushed buffer, retrying");
1629 if (!circular_trace_buffer)
1631 trace_debug (
"Not enough space in the trace buffer");
1635 trace_debug (
"Need more space in the trace buffer");
1640 if (oldest->
tpnum == 0)
1659 if (new_start < tbctrl->start)
1664 tbctrl->
start = new_start;
1668 "Trace buffer [%d], start=%d free=%d "
1669 "endfree=%d wrap=%d hi=%d",
1671 (
int) (tbctrl->
start - trace_buffer_lo),
1672 (
int) (tbctrl->
free - trace_buffer_lo),
1673 (
int) (tbctrl->
end_free - trace_buffer_lo),
1674 (
int) (tbctrl->
wrap - trace_buffer_lo),
1675 (
int) (trace_buffer_hi - trace_buffer_lo));
1685 rslt = tbctrl->
free;
1696 #ifdef IN_PROCESS_AGENT
1705 readout =
cmpxchg (&trace_buffer_ctrl_curr, prev, commit);
1706 if (readout != prev)
1708 trace_debug (
"GDBserver has touched the trace buffer, restarting."
1709 " (prev=%08x, commit=%08x, readout=%08x)",
1710 prev, commit, readout);
1720 about_to_request_buffer_space ();
1726 unsigned int refetch;
1730 refetch = trace_buffer_ctrl_curr;
1732 if (refetch == commit
1736 trace_debug (
"change is effective: (prev=%08x, commit=%08x, "
1737 "readout=%08x, refetch=%08x)",
1738 prev, commit, readout, refetch);
1742 trace_debug (
"GDBserver has touched the trace buffer, not effective."
1743 " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1744 prev, commit, readout, refetch);
1763 trace_debug (
"Trace buffer [%d] start=%d free=%d "
1764 "endfree=%d wrap=%d hi=%d",
1766 (
int) (tbctrl->
start - trace_buffer_lo),
1767 (
int) (tbctrl->
free - trace_buffer_lo),
1768 (
int) (tbctrl->
end_free - trace_buffer_lo),
1769 (
int) (tbctrl->
wrap - trace_buffer_lo),
1770 (
int) (trace_buffer_hi - trace_buffer_lo));
1776 #ifndef IN_PROCESS_AGENT
1788 + (trace_buffer_hi - trace_buffer_free));
1810 tpoint->
cond = NULL;
1820 tpoint->
next = NULL;
1841 for (tp_next = &tracepoints;
1843 tp_next = &(*tp_next)->
next)
1845 tpoint->
next = *tp_next;
1847 last_tracepoint = tpoint;
1849 seen_step_action_flag = 0;
1854 #ifndef IN_PROCESS_AGENT
1863 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
1877 for (tp = tracepoints, tp_prev = NULL; tp && tp != tpoint;
1878 tp_prev = tp, tp = tp->
next)
1886 tracepoints = tp->
next;
1903 tpoint = prev_tp->
next;
1906 for (; tpoint; tpoint = tpoint->
next)
1907 if (tpoint->
number == num)
1924 seen_step_action_flag = 1;
1932 char *act_start = act;
1943 maction =
xmalloc (
sizeof *maction);
1946 action = &maction->
base;
1949 is_neg = (*act ==
'-');
1960 trace_debug (
"Want to collect %s bytes at 0x%s (basereg %d)",
1969 raction =
xmalloc (
sizeof *raction);
1972 action = &raction->
base;
1977 while (isxdigit(*act))
1985 raction =
xmalloc (
sizeof *raction);
1988 action = &raction->
base;
1990 trace_debug (
"Want to collect static trace data");
2002 xaction =
xmalloc (
sizeof (*xaction));
2005 action = &xaction->
base;
2012 trace_debug (
"unknown trace action '%c', ignoring...", *act);
2021 if (seen_step_action_flag)
2062 #ifdef IN_PROCESS_AGENT
2064 for (tsv = alloced_trace_state_variables; tsv; tsv = tsv->
next)
2070 for (tsv = trace_state_variables; tsv; tsv = tsv->
next)
2095 #ifdef IN_PROCESS_AGENT
2098 tsv->
next = alloced_trace_state_variables;
2099 alloced_trace_state_variables = tsv;
2105 trace_state_variables = tsv;
2119 trace_debug (
"No trace state variable %d, skipping value get", num);
2130 trace_debug (
"get_trace_state_variable_value(%d) ==> %s",
2145 trace_debug (
"No trace state variable %d, skipping value set", num);
2173 trace_debug (
"No trace state variable %d, skipping name set", num);
2177 tsv->
name = (
char *) name;
2189 trace_debug (
"No trace state variable %d, skipping getter set", num);
2216 static unsigned char *
2220 unsigned char *block;
2247 #ifndef IN_PROCESS_AGENT
2297 *tfnump = current_traceframe + 1;
2310 ? (lo <= tfaddr && tfaddr <= hi)
2311 : (lo > tfaddr || tfaddr > hi))
2329 *tfnump = current_traceframe + 1;
2340 if (tframe->
tpnum == num)
2351 #ifndef IN_PROCESS_AGENT
2368 current_traceframe = -1;
2378 last_tracepoint = NULL;
2393 trace_state_variables =
next;
2418 sprintf (cmd,
"unprobe_marker_at:%s",
paddress (address));
2434 prev_stpoint = NULL;
2437 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
2441 if (tpoint->
handle == NULL)
2444 "never installed, nothing to clear",
2449 switch (tpoint->
type)
2458 if (prev_stpoint != NULL
2467 prev_stpoint = tpoint;
2485 int trail_hyphen = 0;
2493 packet += strlen (
"QTDP:");
2517 " at 0x%s already exists",
2525 tpoint->
enabled = (*packet ==
'E');
2534 while (*packet ==
':')
2544 else if (*packet ==
'S')
2549 else if (*packet ==
'X')
2551 actparm = (
char *) packet;
2555 else if (*packet ==
'-')
2557 else if (*packet ==
'\0')
2560 trace_debug (
"Unknown optional tracepoint field");
2569 "enabled %d step %" PRIu64
" pass %" PRIu64,
2579 trace_debug (
"Tracepoint error: tracepoint %d at 0x%s not found",
2589 if (tracing && !trail_hyphen)
2607 for (tp = tracepoints; tp; tp = tp->
next)
2620 tpoint->
handle = (
void *) -1;
2643 if (strcmp (own_buf,
"OK") != 0)
2663 char *saved, *srctype, *src;
2667 packet += strlen (
"QTDPsrc:");
2679 trace_debug (
"Tracepoint error: tracepoint %d at 0x%s not found",
2686 packet = strchr (packet,
':');
2687 srctype =
xmalloc (packet - saved + 1);
2688 memcpy (srctype, saved, packet - saved);
2689 srctype[packet - saved] =
'\0';
2700 newlast->
type = srctype;
2702 newlast->
next = NULL;
2710 last->
next = newlast;
2727 packet += strlen (
"QTDV:");
2736 nbytes = strlen (packet) / 2;
2737 varname =
xmalloc (nbytes + 1);
2739 varname[nbytes] =
'\0';
2743 tsv->
name = varname;
2757 packet += strlen (enable ?
"QTEnable:" :
"QTDisable:");
2768 trace_debug (
"Tracepoint %d at 0x%s is already %s",
2770 enable ?
"enabled" :
"disabled");
2776 enable ?
"Enabling" :
"Disabling",
2790 trace_debug (
"Failed to temporarily stop inferior threads");
2801 "inferior process memory");
2825 packet += strlen (
"qTV:");
2828 if (current_traceframe >= 0)
2833 strcpy (own_buf,
"U");
2840 else if (!tracing && strcmp (tracing_stop_reason,
"tnotrun") == 0)
2842 strcpy (own_buf,
"U");
2848 sprintf (own_buf,
"V%s",
phex_nz (val, 0));
2858 while (readonly_regions)
2861 readonly_regions = readonly_regions->
next;
2881 packet += strlen (
"QTro");
2883 while (*packet ==
':')
2893 readonly_regions = roreg;
2894 trace_debug (
"Added readonly region from 0x%s to 0x%s",
2910 for (roreg = readonly_regions; roreg; roreg = roreg->
next)
2911 if (roreg->
start <= addr && (addr + length - 1) <= roreg->
end)
2918 static const int max_jump_pad_size = 0x100;
2927 if (gdb_jump_pad_head == 0)
2930 &gdb_jump_pad_head))
2933 "error extracting jump_pad_buffer");
2945 trace_debug (
"claim_jump_space reserves %s bytes at %s",
2947 gdb_jump_pad_head += used;
2960 if (!trampoline_buffer_head)
2963 &trampoline_buffer_tail))
2966 "error extracting trampoline_buffer");
2970 &trampoline_buffer_head))
2973 "error extracting trampoline_buffer_end");
2981 if (trampoline_buffer_head - trampoline_buffer_tail < used)
2983 trace_debug (
"claim_trampoline_space failed to reserve %s bytes",
2988 trampoline_buffer_head -= used;
2990 trace_debug (
"claim_trampoline_space reserves %s bytes at %s",
3009 "error extracting trampoline_buffer_end");
3015 strcpy (buf,
"was claiming");
3020 "error extracting errbuf");
3026 return trampoline_end != 0;
3041 sprintf (cmd,
"probe_marker_at:%s",
paddress (address));
3048 strcpy (errout, cmd);
3071 #define MAX_JUMP_SIZE 20
3090 trace_debug (
"Requested a fast tracepoint on an instruction "
3091 "that is of less than the minimum length.");
3098 trampoline_size = 0;
3107 &trampoline, &trampoline_size,
3120 if (tpoint->
handle != NULL)
3128 jentry = ((jentry + 7) & ~0x7);
3157 trace_debug (
"Requested a %s tracepoint, but fast "
3158 "tracepoints aren't supported.",
3166 trace_debug (
"Requested a static tracepoint, but static "
3167 "tracepoints are not supported.");
3177 tpoint->
handle = (
void *) -1;
3184 if (tpoint->
handle == NULL)
3186 if (*own_buf ==
'\0')
3198 struct tracepoint *tpoint, *prev_ftpoint, *prev_stpoint;
3220 prev_ftpoint = NULL;
3223 prev_stpoint = NULL;
3232 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
3252 trace_debug (
"Requested a %s tracepoint, but fast "
3253 "tracepoints aren't supported.",
3255 ?
"static" :
"fast");
3264 if (prev_ftpoint != NULL
3289 prev_ftpoint = tpoint;
3296 trace_debug (
"Requested a static tracepoint, but static "
3297 "tracepoints are not supported.");
3303 if (prev_stpoint != NULL
3305 tpoint->
handle = (
void *) -1;
3310 tpoint->
handle = (
void *) -1;
3314 prev_stpoint = tpoint;
3322 if (tpoint == tracepoints)
3334 if (tpoint->
handle == NULL)
3344 if (*packet ==
'\0')
3350 stopping_tracepoint = NULL;
3351 trace_buffer_is_full = 0;
3353 error_tracepoint = NULL;
3364 "Error setting tracing variable in lib");
3371 "Error clearing stopping_tracepoint variable"
3378 "Error clearing trace_buffer_is_full variable"
3384 if (stop_tracing_bkpt == NULL)
3385 error (
"Error setting stop_tracing breakpoint");
3387 flush_trace_buffer_bkpt
3390 if (flush_trace_buffer_bkpt == NULL)
3391 error (
"Error setting flush_trace_buffer breakpoint");
3431 "Error clearing tracing variable in lib");
3436 tracing_stop_reason =
"t???";
3437 tracing_stop_tpnum = 0;
3438 if (stopping_tracepoint)
3441 "tracepoint %d was hit %" PRIu64
" times",
3442 stopping_tracepoint->
number,
3444 tracing_stop_reason =
"tpasscount";
3445 tracing_stop_tpnum = stopping_tracepoint->
number;
3447 else if (trace_buffer_is_full)
3449 trace_debug (
"Stopping the trace because the trace buffer is full");
3450 tracing_stop_reason =
"tfull";
3454 trace_debug (
"Stopping the trace because of an expression eval error");
3456 tracing_stop_tpnum = error_tracepoint->
number;
3458 #ifndef IN_PROCESS_AGENT
3461 trace_debug (
"Stopping the trace because GDB disconnected");
3462 tracing_stop_reason =
"tdisconnected";
3467 trace_debug (
"Stopping the trace because of a tstop command");
3468 tracing_stop_reason =
"tstop";
3471 stopping_tracepoint = NULL;
3472 error_tracepoint = NULL;
3486 if (stop_tracing_bkpt != NULL)
3489 stop_tracing_bkpt = NULL;
3492 if (flush_trace_buffer_bkpt != NULL)
3495 flush_trace_buffer_bkpt = NULL;
3533 packet += strlen (
"QTDisconnected:");
3539 disconnected_tracing = setting;
3550 packet += strlen (
"QTFrame:");
3554 packet += strlen (
"pc:");
3561 packet += strlen (
"range:");
3565 trace_debug (
"Want to find next traceframe in the range 0x%s to 0x%s",
3571 packet += strlen (
"outside:");
3576 "outside the range 0x%s to 0x%s",
3582 packet += strlen (
"tdp:");
3585 trace_debug (
"Want to find next traceframe for tracepoint %d", tpnum);
3591 tfnum = (int) frame;
3594 trace_debug (
"Want to stop looking at traceframes");
3595 current_traceframe = -1;
3599 trace_debug (
"Want to look at traceframe %d", tfnum);
3605 current_traceframe = tfnum;
3606 sprintf (own_buf,
"F%xT%x", tfnum, tframe->
tpnum);
3609 sprintf (own_buf,
"F-1");
3615 char *stop_reason_rsp = NULL;
3616 char *buf1, *buf2, *buf3;
3623 str = (tracing_user_name ? tracing_user_name :
"");
3624 slen = strlen (str);
3625 buf1 = (
char *)
alloca (slen * 2 + 1);
3628 str = (tracing_notes ? tracing_notes :
"");
3629 slen = strlen (str);
3630 buf2 = (
char *)
alloca (slen * 2 + 1);
3633 str = (tracing_stop_note ? tracing_stop_note :
"");
3634 slen = strlen (str);
3635 buf3 = (
char *)
alloca (slen * 2 + 1);
3638 trace_debug (
"Returning trace status as %d, stop reason %s",
3639 tracing, tracing_stop_reason);
3650 stop_reason_rsp = (
char *) tracing_stop_reason;
3657 const char *result_name;
3661 result_name = stop_reason_rsp + strlen (
"terror:");
3662 hexstr_len = strlen (result_name) * 2;
3663 p = stop_reason_rsp =
alloca (strlen (
"terror:") + hexstr_len + 1);
3664 strcpy (p,
"terror:");
3670 if (strcmp (stop_reason_rsp,
"tstop") == 0)
3672 stop_reason_rsp =
alloca (strlen (
"tstop:") + strlen (buf3) + 1);
3673 strcpy (stop_reason_rsp,
"tstop:");
3674 strcat (stop_reason_rsp, buf3);
3680 "tframes:%x;tcreated:%x;"
3681 "tfree:%x;tsize:%s;"
3684 "starttime:%s;stoptime:%s;"
3685 "username:%s;notes:%s:",
3687 stop_reason_rsp, tracing_stop_tpnum,
3690 circular_trace_buffer,
3691 disconnected_tracing,
3692 phex_nz (tracing_start_time,
sizeof (tracing_start_time)),
3693 phex_nz (tracing_stop_time,
sizeof (tracing_stop_time)),
3704 packet += strlen (
"qTP:");
3715 trace_debug (
"Tracepoint error: tracepoint %d at 0x%s not found",
3721 sprintf (own_buf,
"V%" PRIu64
":%" PRIu64
"", tpoint->
hit_count,
3740 sprintf (packet,
"T%x:%s:%c:%" PRIx64
":%" PRIx64, tpoint->
number,
3745 sprintf (packet + strlen (packet),
":F%x", tpoint->
orig_size);
3747 sprintf (packet + strlen (packet),
":S");
3752 sprintf (packet + strlen (packet),
":X%x,%s",
3766 char *taction,
int step)
3768 sprintf (packet,
"%c%x:%s:%s",
3783 len = strlen (src->
str);
3784 buf =
alloca (len * 2 + 1);
3787 sprintf (packet,
"Z%x:%s:%s:%x:%x:%s",
3789 src->
type, 0, len, buf);
3799 trace_debug (
"Returning first tracepoint definition piece");
3802 cur_action = cur_step_action = 0;
3803 cur_source_string = NULL;
3808 strcpy (packet,
"l");
3819 trace_debug (
"Returning subsequent tracepoint definition piece");
3825 strcpy (packet,
"l");
3827 else if (cur_action < cur_tpoint->numactions)
3833 else if (cur_step_action < cur_tpoint->num_step_actions)
3839 else if ((cur_source_string
3840 ? cur_source_string->
next
3843 if (cur_source_string)
3844 cur_source_string = cur_source_string->
next;
3851 cur_tpoint = cur_tpoint->
next;
3852 cur_action = cur_step_action = 0;
3853 cur_source_string = NULL;
3857 strcpy (packet,
"l");
3867 char *buf = (
char *)
"";
3872 namelen = strlen (tsv->
name);
3873 buf =
alloca (namelen * 2 + 1);
3878 tsv->
getter ? 1 : 0, buf);
3887 trace_debug (
"Returning first trace state variable definition");
3894 strcpy (packet,
"l");
3902 trace_debug (
"Returning additional trace state variable definition");
3906 cur_tsv = cur_tsv->
next;
3910 strcpy (packet,
"l");
3913 strcpy (packet,
"l");
3974 strcpy (buf,
"close");
3991 strcpy (packet,
"0");
4009 packet += strlen (
"qTBuffer:");
4015 trace_debug (
"Want to get trace buffer, %d bytes at offset 0x%s",
4016 (
int) num,
phex_nz (offset, 0));
4023 strcpy (own_buf,
"l");
4041 if (num > tot - offset)
4045 if (num >= (
PBUFSIZ - 16) / 2 )
4057 packet += strlen (
"QTBuffer:circular:");
4060 circular_trace_buffer = val;
4062 circular_trace_buffer ?
"circular" :
"linear");
4080 packet += strlen (
"QTBuffer:size:");
4083 if (strcmp (packet,
"-1") == 0)
4101 char *saved, *user, *notes, *stopnote;
4104 packet += strlen (
"QTNotes:");
4110 packet += strlen (
"user:");
4112 packet = strchr (packet,
';');
4113 nbytes = (packet - saved) / 2;
4116 user[nbytes] =
'\0';
4119 xfree (tracing_user_name);
4120 tracing_user_name = user;
4124 packet += strlen (
"notes:");
4126 packet = strchr (packet,
';');
4127 nbytes = (packet - saved) / 2;
4130 notes[nbytes] =
'\0';
4133 xfree (tracing_notes);
4134 tracing_notes = notes;
4138 packet += strlen (
"tstop:");
4140 packet = strchr (packet,
';');
4141 nbytes = (packet - saved) / 2;
4142 stopnote =
xmalloc (nbytes + 1);
4144 stopnote[nbytes] =
'\0';
4147 xfree (tracing_stop_note);
4148 tracing_stop_note = stopnote;
4160 if (strcmp (
"QTinit", packet) == 0)
4195 else if (strcmp (
"QTStart", packet) == 0)
4200 else if (strcmp (
"QTStop", packet) == 0)
4205 else if (
startswith (packet,
"QTDisconnected:"))
4215 else if (
startswith (packet,
"QTBuffer:circular:"))
4220 else if (
startswith (packet,
"QTBuffer:size:"))
4237 if (strcmp (
"qTStatus", packet) == 0)
4247 else if (strcmp (
"qTfP", packet) == 0)
4252 else if (strcmp (
"qTsP", packet) == 0)
4257 else if (strcmp (
"qTfV", packet) == 0)
4262 else if (strcmp (
"qTsV", packet) == 0)
4277 else if (strcmp (
"qTfSTM", packet) == 0)
4282 else if (strcmp (
"qTsSTM", packet) == 0)
4292 else if (strcmp (
"qTMinFTPILen", packet) == 0)
4302 #ifndef IN_PROCESS_AGENT
4329 wstep =
xmalloc (
sizeof (*wstep));
4400 trace_debug (
"Thread %s finished a single-step for tracepoint %d at 0x%s",
4407 while (wstep != NULL)
4412 trace_debug (
"NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
4417 *wstep_link = wstep->
next;
4419 wstep = *wstep_link;
4433 trace_debug (
"Thread %s done stepping for tracepoint %d at 0x%s",
4438 *wstep_link = wstep->
next;
4440 wstep = *wstep_link;
4446 && stopping_tracepoint == NULL)
4447 stopping_tracepoint = tpoint;
4453 wstep_link = &wstep->
next;
4454 wstep = *wstep_link;
4457 if (stopping_tracepoint
4458 || trace_buffer_is_full
4488 int ipa_trace_buffer_is_full;
4490 int ipa_expr_eval_result;
4496 &ipa_trace_buffer_is_full);
4499 &ipa_stopping_tracepoint);
4503 &ipa_error_tracepoint);
4507 &ipa_expr_eval_result);
4511 "stopping_tracepoint: %s, "
4512 "ipa_expr_eval_result: %d, "
4513 "error_tracepoint: %s, ",
4514 ipa_trace_buffer_is_full,
4515 paddress (ipa_stopping_tracepoint),
4516 ipa_expr_eval_result,
4521 if (ipa_trace_buffer_is_full)
4523 if (ipa_stopping_tracepoint)
4525 if (ipa_stopping_tracepoint)
4529 if (ipa_stopping_tracepoint != 0)
4536 expr_eval_result = ipa_expr_eval_result;
4545 trace_debug (
"lib stopped at flush_trace_buffer");
4569 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
4580 trace_debug (
"Thread %s at address of tracepoint %d at 0x%s",
4591 if (stopping_tracepoint
4592 || trace_buffer_is_full
4615 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4616 struct ust_marker_data;
4641 && stopping_tracepoint == NULL)
4642 stopping_tracepoint = tpoint;
4644 trace_debug (
"Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64,
4651 for (acti = 0; acti < tpoint->
numactions; ++acti)
4653 #ifndef IN_PROCESS_AGENT
4654 trace_debug (
"Tracepoint %d at 0x%s about to do action '%s'",
4666 if (tframe == NULL && tracing)
4667 trace_buffer_is_full = 1;
4670 #ifndef IN_PROCESS_AGENT
4681 "tracepoint %d at 0x%s, step %d of %" PRIu64
", hit %" PRIu64,
4692 trace_debug (
"Tracepoint %d at 0x%s about to do step action '%s'",
4703 if (tframe == NULL && tracing)
4704 trace_buffer_is_full = 1;
4709 #ifdef IN_PROCESS_AGENT
4722 #ifdef IN_PROCESS_AGENT
4725 struct fast_tracepoint_ctx *fctx = (
struct fast_tracepoint_ctx *) ctx;
4726 if (!fctx->regcache_initted)
4728 fctx->regcache_initted = 1;
4733 regcache = &fctx->regcache;
4738 struct static_tracepoint_ctx *sctx
4739 = (
struct static_tracepoint_ctx *) ctx;
4741 if (!sctx->regcache_initted)
4743 sctx->regcache_initted = 1;
4748 supply_static_tracepoint_registers (&sctx->regcache,
4749 (
const unsigned char *)
4751 sctx->tpoint->address);
4753 regcache = &sctx->regcache;
4778 switch (taction->
type)
4790 trace_debug (
"Want to collect %s bytes at 0x%s (basereg %d)",
4792 paddress (maction->addr), maction->basereg);
4800 unsigned char *regspace;
4812 if (regspace == NULL)
4814 trace_debug (
"Trace buffer block allocation failed, skipping");
4828 #ifndef IN_PROCESS_AGENT
4839 trace_debug (
"Storing stop pc (0x%s) in regblock",
4871 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4872 trace_debug (
"Want to collect static trace data");
4873 collect_ust_data_at_tracepoint (ctx, tframe);
4875 trace_debug (
"warning: collecting static trace data, "
4876 "but static tracepoints are not supported");
4907 #ifdef IN_PROCESS_AGENT
4928 trace_debug (
"Tracepoint %d at 0x%s condition evals to %s",
4931 return (value ? 1 : 0);
4941 unsigned char *mspace;
4943 unsigned short blocklen;
4953 while (remaining > 0)
4957 blocklen = (remaining > 65535 ? 65535 : remaining);
4958 sp = 1 +
sizeof (from) +
sizeof (blocklen) + blocklen;
4966 memcpy (mspace, &from,
sizeof (from));
4967 mspace +=
sizeof (from);
4968 memcpy (mspace, &blocklen,
sizeof (blocklen));
4969 mspace +=
sizeof (blocklen);
4973 remaining -= blocklen;
4983 unsigned char *buf, *mspace;
4985 unsigned short blocklen, i;
4990 while (remaining > 0)
4994 blocklen = (remaining > 65535 ? 65535 : remaining);
4998 buf = (
unsigned char *)
xmalloc (blocklen + 1);
4999 for (i = 0; i < blocklen; ++i)
5011 remaining = blocklen;
5015 sp = 1 +
sizeof (from) +
sizeof (blocklen) + blocklen;
5026 memcpy ((
void *) mspace, (
void *) &from,
sizeof (from));
5027 mspace +=
sizeof (from);
5028 memcpy ((
void *) mspace, (
void *) &blocklen,
sizeof (blocklen));
5029 mspace +=
sizeof (blocklen);
5031 memcpy ((
void *) mspace, (
void *) buf, blocklen);
5032 remaining -= blocklen;
5044 unsigned char *vspace;
5048 1 + sizeof (n) +
sizeof (
LONGEST));
5054 memcpy (vspace + 1, &n,
sizeof (n));
5056 memcpy (vspace + 1 +
sizeof (n), &val,
sizeof (val));
5061 #ifndef IN_PROCESS_AGENT
5069 char *wantedp = data;
5071 if (*wantedp == blocktype)
5084 static unsigned char *
5087 int (*callback) (
char blocktype,
5088 unsigned char *dataptr,
5092 unsigned char *dataptr;
5102 for (dataptr = database;
5103 dataptr < database + datasize;
5107 unsigned short mlen;
5113 datasize = dataptr - database;
5117 blocktype = *dataptr++;
5119 if ((*callback) (blocktype, dataptr, data))
5131 memcpy (&mlen, dataptr,
sizeof (mlen));
5132 dataptr += (
sizeof (mlen) + mlen);
5136 dataptr += (
sizeof (int) +
sizeof (
LONGEST));
5140 memcpy (&mlen, dataptr,
sizeof (mlen));
5141 dataptr += (
sizeof (mlen) + mlen);
5144 trace_debug (
"traceframe %d has unknown block type 0x%x",
5157 static unsigned char *
5159 int tfnum,
char type_wanted)
5165 static unsigned char *
5168 unsigned char *regblock;
5174 if (regblock == NULL)
5175 trace_debug (
"traceframe %d has no register data", tfnum);
5185 unsigned char *dataptr;
5198 if (dataptr == NULL)
5220 unsigned char *dataptr;
5224 if (dataptr == NULL)
5235 unsigned char *buf,
ULONGEST length,
5239 unsigned char *database, *dataptr;
5240 unsigned int datasize;
5242 unsigned short mlen;
5255 database = dataptr = &tframe->
data[0];
5260 - (dataptr - database),
5261 tfnum,
'M')) != NULL)
5263 memcpy (&maddr, dataptr,
sizeof (maddr));
5264 dataptr +=
sizeof (maddr);
5265 memcpy (&mlen, dataptr,
sizeof (mlen));
5266 dataptr +=
sizeof (mlen);
5273 if (maddr <= addr && addr < (maddr + mlen))
5275 ULONGEST amt = (maddr + mlen) - addr;
5279 memcpy (buf, dataptr + (addr - maddr), amt);
5288 trace_debug (
"traceframe %d has no memory data for the desired region",
5300 unsigned char *database, *dataptr;
5301 unsigned int datasize;
5324 database = dataptr = &tframe->
data[0];
5330 - (dataptr - database),
5331 tfnum,
'V')) != NULL)
5333 memcpy (&vnum, dataptr,
sizeof (vnum));
5334 dataptr +=
sizeof (vnum);
5336 trace_debug (
"traceframe %d has variable %d", tfnum, vnum);
5341 memcpy (val, dataptr,
sizeof (*val));
5350 trace_debug (
"traceframe %d has no data for variable %d",
5360 unsigned char *buf,
ULONGEST length,
5364 unsigned char *database, *dataptr;
5365 unsigned int datasize;
5366 unsigned short mlen;
5379 database = &tframe->
data[0];
5385 if (dataptr != NULL)
5387 memcpy (&mlen, dataptr,
sizeof (mlen));
5388 dataptr +=
sizeof (mlen);
5391 if (offset + length > mlen)
5394 memcpy (buf, dataptr, length);
5402 trace_debug (
"traceframe %d has no static trace data", tfnum);
5421 unsigned short mlen;
5424 memcpy (&maddr, dataptr,
sizeof (maddr));
5425 dataptr +=
sizeof (maddr);
5426 memcpy (&mlen, dataptr,
sizeof (mlen));
5427 dataptr +=
sizeof (mlen);
5429 "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5437 memcpy (&vnum, dataptr,
sizeof (vnum));
5447 warning (
"Unhandled trace block type (%d) '%c ' "
5448 "while building trace frame info.",
5449 blocktype, blocktype);
5488 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
5503 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
5522 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
5550 #ifndef IN_PROCESS_AGENT
5574 CORE_ADDR ipa_gdb_jump_pad_buffer, ipa_gdb_jump_pad_buffer_end;
5576 CORE_ADDR ipa_gdb_trampoline_buffer_end;
5578 int needs_breakpoint;
5605 needs_breakpoint = 0;
5609 &ipa_gdb_jump_pad_buffer))
5612 "error extracting `gdb_jump_pad_buffer'");
5615 &ipa_gdb_jump_pad_buffer_end))
5618 "error extracting `gdb_jump_pad_buffer_end'");
5622 &ipa_gdb_trampoline_buffer))
5625 "error extracting `gdb_trampoline_buffer'");
5628 &ipa_gdb_trampoline_buffer_end))
5631 "error extracting `gdb_trampoline_buffer_end'");
5634 if (ipa_gdb_jump_pad_buffer <= stop_pc
5635 && stop_pc < ipa_gdb_jump_pad_buffer_end)
5642 warning (
"in jump pad, but no matching tpoint?");
5647 trace_debug (
"in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5660 needs_breakpoint = 1;
5662 else if (ipa_gdb_trampoline_buffer <= stop_pc
5663 && stop_pc < ipa_gdb_trampoline_buffer_end)
5670 warning (
"in trampoline, but no matching tpoint?");
5675 trace_debug (
"in trampoline of tpoint (%d, %s); trampoline(%s, %s)",
5684 needs_breakpoint = 1;
5698 " failed reading 'collecting' in the inferior");
5702 if (!ipa_collecting)
5704 trace_debug (
"fast_tracepoint_collecting: not collecting"
5705 " (and nobody is).");
5711 (
unsigned char *) &ipa_collecting_obj,
5712 sizeof (ipa_collecting_obj)) != 0)
5715 if (ipa_collecting_obj.
thread_area != thread_area)
5717 trace_debug (
"fast_tracepoint_collecting: not collecting "
5718 "(another thread is)");
5726 warning (
"fast_tracepoint_collecting: collecting, "
5727 "but tpoint %s not found?",
5734 needs_breakpoint = 1;
5746 if (needs_breakpoint)
5753 fast_tracepoint_collecting, returning continue-until-break at %s",
5762 trace_debug (
"fast_tracepoint_collecting, returning "
5763 "need-single-step (%s-%s)",
5773 #ifdef IN_PROCESS_AGENT
5789 gdb_collect (
struct tracepoint *tpoint,
unsigned char *regs)
5791 struct fast_tracepoint_ctx ctx;
5799 ctx.regcache_initted = 0;
5803 if (ctx.regspace == NULL)
5805 trace_debug (
"Trace buffer block allocation failed, skipping");
5809 for (ctx.tpoint = tpoint;
5810 ctx.tpoint != NULL && ctx.tpoint->address == tpoint->
address;
5811 ctx.tpoint = ctx.tpoint->next)
5813 if (!ctx.tpoint->enabled)
5818 if (ctx.tpoint->
type != tpoint->
type)
5822 if (ctx.tpoint->cond == NULL
5827 ctx.tpoint->address, ctx.tpoint);
5833 if (stopping_tracepoint
5834 || trace_buffer_is_full
5857 #ifndef IN_PROCESS_AGENT
5884 trace_debug (
"Starting condition compilation for tracepoint %d\n",
5901 trace_debug (
"Condition compilation for tracepoint %d complete\n",
5910 trace_debug (
"Condition compilation for tracepoint %d failed, "
5931 (
unsigned char *) &ptr,
sizeof (
void *));
5949 if (target_tp_heap == 0)
5956 "couldn't get target heap head pointer");
5961 target_tp_heap += size;
5964 target_tp_heap = ((target_tp_heap + 7) & ~0x7);
5987 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
6006 if (tpoint->
cond != NULL)
6011 jentry =
UALIGN (jentry, 8);
6017 jentry =
UALIGN (jentry, 8);
6021 target_tracepoint = *tpoint;
6029 target_tracepoint.
next = NULL;
6035 sizeof (target_tracepoint));
6060 if (ipa_action != 0)
6062 (actions_array + i *
sizeof (*tpoint->
actions),
6068 #define IPA_PROTO_FAST_TRACE_FLAG 0
6069 #define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
6070 #define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
6071 #define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
6072 #define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
6084 strcpy (p,
"FastTrace:");
6107 p[0] = action->
type;
6108 p = action->
ops->
send (&p[1], action);
6116 memcpy (p, &gdb_jump_pad_head, 8);
6137 trace_debug (
"agent: read from cmd_buf 0x%x 0x%x\n",
6139 (
unsigned int) gdb_jump_pad_head);
6167 for (tp = tracepoints; tp != tpoint; tp = tp->
next)
6180 &tp_prev_target_next_addr))
6183 "error reading `tp_prev->next'");
6189 tp_prev_target_next_addr);
6212 for (tsv = trace_state_variables; tsv != NULL; tsv = tsv->
next)
6226 if (tsv == trace_state_variables)
6244 target_tsv.
next = NULL;
6247 sizeof (target_tsv));
6249 if (tsv->
name != NULL)
6251 size_t size = strlen (tsv->
name) + 1;
6254 (
unsigned char *) tsv->
name, size);
6282 unsigned int ipa_traceframe_read_count, ipa_traceframe_write_count;
6283 unsigned int ipa_traceframe_read_count_racy, ipa_traceframe_write_count_racy;
6286 unsigned int curr_tbctrl_idx;
6287 unsigned int ipa_trace_buffer_ctrl_curr;
6288 unsigned int ipa_trace_buffer_ctrl_curr_old;
6290 struct breakpoint *about_to_request_buffer_space_bkpt;
6295 &ipa_traceframe_read_count_racy))
6303 &ipa_traceframe_write_count_racy))
6306 trace_debug (
"ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6307 ipa_traceframe_write_count_racy
6308 - ipa_traceframe_read_count_racy,
6309 ipa_traceframe_write_count_racy,
6310 ipa_traceframe_read_count_racy);
6312 if (ipa_traceframe_write_count_racy == ipa_traceframe_read_count_racy)
6315 about_to_request_buffer_space_bkpt
6320 &ipa_trace_buffer_ctrl_curr))
6323 ipa_trace_buffer_ctrl_curr_old = ipa_trace_buffer_ctrl_curr;
6333 counter = (prev + 0x100) & GDBSERVER_FLUSH_COUNT_MASK_CURR;
6342 ipa_trace_buffer_ctrl_curr))
6346 ipa_trace_buffer_ctrl_curr_old,
6347 ipa_trace_buffer_ctrl_curr);
6359 &ipa_traceframe_read_count))
6362 &ipa_traceframe_write_count))
6367 trace_debug (
"ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6368 ipa_traceframe_write_count - ipa_traceframe_read_count,
6369 ipa_traceframe_write_count, ipa_traceframe_read_count);
6371 if (ipa_traceframe_write_count != ipa_traceframe_write_count_racy
6372 || ipa_traceframe_read_count != ipa_traceframe_read_count_racy)
6373 trace_debug (
"note that ipa_traceframe_count's parts changed");
6380 ipa_trace_buffer_ctrl_addr
6384 (
unsigned char *) &ipa_trace_buffer_ctrl,
6389 &ipa_trace_buffer_lo))
6392 &ipa_trace_buffer_hi))
6398 trace_debug (
"Lib: Trace buffer [%d] start=%d free=%d "
6399 "endfree=%d wrap=%d hi=%d",
6401 (
int) (ipa_trace_buffer_ctrl.
start - ipa_trace_buffer_lo),
6402 (
int) (ipa_trace_buffer_ctrl.
free - ipa_trace_buffer_lo),
6403 (
int) (ipa_trace_buffer_ctrl.
end_free - ipa_trace_buffer_lo),
6404 (
int) (ipa_trace_buffer_ctrl.
wrap - ipa_trace_buffer_lo),
6405 (
int) (ipa_trace_buffer_hi - ipa_trace_buffer_lo));
6409 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6411 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6412 ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6414 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6415 (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6416 - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6417 ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6422 while (ipa_traceframe_write_count - ipa_traceframe_read_count)
6426 unsigned char *block;
6431 error (
"Uploading: couldn't read traceframe at %s\n",
paddress (tf));
6433 if (ipa_tframe.
tpnum == 0)
6436 "Uploading: No (more) fast traceframes, but"
6437 " ipa_traceframe_count == %u??\n",
6438 ipa_traceframe_write_count
6439 - ipa_traceframe_read_count);
6449 trace_buffer_is_full = 1;
6463 error (
"Uploading: Couldn't read traceframe data at %s\n",
6475 if (tf < ipa_trace_buffer_ctrl.
start)
6477 trace_debug (
"Lib: Discarding past the wraparound");
6478 ipa_trace_buffer_ctrl.
wrap = ipa_trace_buffer_hi;
6480 ipa_trace_buffer_ctrl.
start = tf;
6481 ipa_trace_buffer_ctrl.
end_free = ipa_trace_buffer_ctrl.
start;
6482 ++ipa_traceframe_read_count;
6484 if (ipa_trace_buffer_ctrl.
start == ipa_trace_buffer_ctrl.
free
6485 && ipa_trace_buffer_ctrl.
start == ipa_trace_buffer_ctrl.
end_free)
6488 "Trace buffer [%d] start=%d free=%d endfree=%d",
6490 (
int) (ipa_trace_buffer_ctrl.
start
6491 - ipa_trace_buffer_lo),
6492 (
int) (ipa_trace_buffer_ctrl.
free
6493 - ipa_trace_buffer_lo),
6494 (
int) (ipa_trace_buffer_ctrl.
end_free
6495 - ipa_trace_buffer_lo));
6497 ipa_trace_buffer_ctrl.
start = ipa_trace_buffer_lo;
6498 ipa_trace_buffer_ctrl.
free = ipa_trace_buffer_lo;
6499 ipa_trace_buffer_ctrl.
end_free = ipa_trace_buffer_hi;
6500 ipa_trace_buffer_ctrl.
wrap = ipa_trace_buffer_hi;
6504 "Lib: Trace buffer [%d] start=%d free=%d "
6505 "endfree=%d wrap=%d hi=%d",
6507 (
int) (ipa_trace_buffer_ctrl.
start - ipa_trace_buffer_lo),
6508 (
int) (ipa_trace_buffer_ctrl.
free - ipa_trace_buffer_lo),
6509 (
int) (ipa_trace_buffer_ctrl.
end_free
6510 - ipa_trace_buffer_lo),
6511 (
int) (ipa_trace_buffer_ctrl.
wrap - ipa_trace_buffer_lo),
6512 (
int) (ipa_trace_buffer_hi - ipa_trace_buffer_lo));
6516 (
unsigned char *) &ipa_trace_buffer_ctrl,
6521 ipa_traceframe_read_count);
6523 trace_debug (
"Done uploading traceframes [%d]\n", curr_tbctrl_idx);
6528 about_to_request_buffer_space_bkpt = NULL;
6532 if (trace_buffer_is_full)
6537 #ifdef IN_PROCESS_AGENT
6550 #define tracepoint ust_tracepoint
6551 #include <ust/ust.h>
6554 extern int serialize_to_text (
char *outbuf,
int bufsize,
6555 const char *fmt, va_list ap);
6557 #define GDB_PROBE_NAME "gdb"
6566 int (*serialize_to_text) (
char *outbuf,
int bufsize,
6567 const char *fmt, va_list ap);
6569 int (*ltt_probe_register) (
struct ltt_available_probe *pdata);
6570 int (*ltt_probe_unregister) (
struct ltt_available_probe *pdata);
6572 int (*ltt_marker_connect) (
const char *channel,
const char *mname,
6574 int (*ltt_marker_disconnect) (
const char *channel,
const char *mname,
6577 void (*marker_iter_start) (
struct marker_iter *iter);
6578 void (*marker_iter_next) (
struct marker_iter *iter);
6579 void (*marker_iter_stop) (
struct marker_iter *iter);
6580 void (*marker_iter_reset) (
struct marker_iter *iter);
6588 #define GET_UST_SYM(SYM) \
6591 if (ust_ops.SYM == NULL) \
6592 ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6593 if (ust_ops.SYM == NULL) \
6597 #define USTF(SYM) ust_ops.SYM
6604 GET_UST_SYM (serialize_to_text);
6606 GET_UST_SYM (ltt_probe_register);
6607 GET_UST_SYM (ltt_probe_unregister);
6608 GET_UST_SYM (ltt_marker_connect);
6609 GET_UST_SYM (ltt_marker_disconnect);
6611 GET_UST_SYM (marker_iter_start);
6612 GET_UST_SYM (marker_iter_next);
6613 GET_UST_SYM (marker_iter_stop);
6614 GET_UST_SYM (marker_iter_reset);
6624 ust_marker_to_static_tracepoint (
const struct marker *mdata)
6628 for (tpoint = tracepoints; tpoint; tpoint = tpoint->
next)
6633 if (tpoint->
address == (uintptr_t) mdata->location)
6646 gdb_probe (
const struct marker *mdata,
void *probe_private,
6647 struct registers *regs,
void *call_private,
6648 const char *fmt, va_list *args)
6651 struct static_tracepoint_ctx ctx;
6661 ctx.regcache_initted = 0;
6669 if (ctx.regspace == NULL)
6671 trace_debug (
"Trace buffer block allocation failed, skipping");
6675 tpoint = ust_marker_to_static_tracepoint (mdata);
6679 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6680 mdata->location, mdata->channel,
6681 mdata->name, mdata->format);
6691 ctx.tpoint = tpoint;
6694 "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6695 mdata->location, mdata->channel,
6696 mdata->name, mdata->format);
6699 if (tpoint->
cond == NULL
6706 if (stopping_tracepoint
6707 || trace_buffer_is_full
6735 struct static_tracepoint_ctx *umd = (
struct static_tracepoint_ctx *) ctx;
6736 unsigned char *bufspace;
6739 unsigned short blocklen;
6743 trace_debug (
"Wanted to collect static trace data, "
6744 "but there's no static trace data");
6748 va_copy (copy, *umd->args);
6749 size = USTF(serialize_to_text) (NULL, 0, umd->fmt, copy);
6756 1 + sizeof (blocklen) + size + 1);
6757 if (bufspace == NULL)
6759 trace_debug (
"Trace buffer block allocation failed, skipping");
6766 blocklen = size + 1;
6767 memcpy (bufspace + 1, &blocklen,
sizeof (blocklen));
6769 va_copy (copy, *umd->args);
6770 USTF(serialize_to_text) ((
char *) bufspace + 1 +
sizeof (blocklen),
6771 size + 1, umd->fmt, copy);
6774 trace_debug (
"Storing static tracepoint data in regblock: %s",
6775 bufspace + 1 +
sizeof (blocklen));
6779 static struct ltt_available_probe gdb_ust_probe =
6789 #ifndef IN_PROCESS_AGENT
6804 trace_debug (
"run_inferior_command: running: %s", cmd);
6819 #include <sys/socket.h>
6822 #ifndef UNIX_PATH_MAX
6823 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6827 #define SOCK_DIR P_tmpdir
6836 init_named_socket (
const char *name)
6839 struct sockaddr_un addr;
6841 result = fd = socket (PF_UNIX, SOCK_STREAM, 0);
6848 addr.sun_family = AF_UNIX;
6850 strncpy (addr.sun_path, name, UNIX_PATH_MAX);
6851 addr.sun_path[UNIX_PATH_MAX - 1] =
'\0';
6853 result = access (name,
F_OK);
6857 result = unlink (name);
6864 warning (
"socket %s already exists; overwriting", name);
6867 result = bind (fd, (
struct sockaddr *) &addr,
sizeof (addr));
6875 result = listen (fd, 1);
6886 static char agent_socket_name[UNIX_PATH_MAX];
6889 gdb_agent_socket_init (
void)
6893 result =
xsnprintf (agent_socket_name, UNIX_PATH_MAX,
"%s/gdb_ust%d",
6894 SOCK_DIR, getpid ());
6895 if (result >= UNIX_PATH_MAX)
6897 trace_debug (
"string overflow allocating socket name");
6901 fd = init_named_socket (agent_socket_name);
6903 warning (
"Error initializing named socket (%s) for communication with the "
6904 "ust helper thread. Check that directory exists and that it "
6905 "is writable.", agent_socket_name);
6913 static const struct marker *next_st;
6920 struct marker_iter iter;
6922 USTF(marker_iter_reset) (&iter);
6923 USTF(marker_iter_start) (&iter);
6930 const struct marker *
6931 next_marker (
const struct marker *m)
6933 struct marker_iter iter;
6935 USTF(marker_iter_reset) (&iter);
6936 USTF(marker_iter_start) (&iter);
6938 for (; iter.marker != NULL; USTF(marker_iter_next) (&iter))
6940 if (iter.marker == m)
6942 USTF(marker_iter_next) (&iter);
6954 cstr_to_hexstr (
const char *str)
6956 int len = strlen (str);
6957 char *hexstr =
xmalloc (len * 2 + 1);
6966 response_ust_marker (
char *packet,
const struct marker *st)
6968 char *strid, *format, *tmp;
6970 next_st = next_marker (st);
6972 tmp =
xmalloc (strlen (st->channel) + 1 +
6973 strlen (st->name) + 1);
6974 sprintf (tmp,
"%s/%s", st->channel, st->name);
6976 strid = cstr_to_hexstr (tmp);
6979 format = cstr_to_hexstr (st->format);
6981 sprintf (packet,
"m%s:%s:%s",
6982 paddress ((uintptr_t) st->location),
6996 trace_debug (
"Returning first trace state variable definition");
6998 if (first_marker ())
6999 response_ust_marker (packet, first_marker ());
7001 strcpy (packet,
"l");
7012 response_ust_marker (packet, next_st);
7014 strcpy (packet,
"l");
7024 struct marker_iter iter;
7026 p +=
sizeof (
"unprobe_marker_at:") - 1;
7030 USTF(marker_iter_reset) (&iter);
7031 USTF(marker_iter_start) (&iter);
7032 for (; iter.marker != NULL; USTF(marker_iter_next) (&iter))
7033 if ((uintptr_t ) iter.marker->location == address)
7037 result = USTF(ltt_marker_disconnect) (iter.marker->channel,
7041 warning (
"could not disable marker %s/%s",
7042 iter.marker->channel, iter.marker->name);
7054 struct marker_iter iter;
7057 p +=
sizeof (
"probe_marker_at:") - 1;
7061 USTF(marker_iter_reset) (&iter);
7063 for (USTF(marker_iter_start) (&iter), m = iter.marker;
7065 USTF(marker_iter_next) (&iter), m = iter.marker)
7066 if ((uintptr_t ) m->location == address)
7071 "ltt_marker_connect (marker = %s/%s)",
7072 m->channel, m->name);
7074 result = USTF(ltt_marker_connect) (m->channel, m->name,
7076 if (result && result != -EEXIST)
7077 trace_debug (
"ltt_marker_connect (marker = %s/%s, errno = %d)",
7078 m->channel, m->name, -result);
7082 sprintf (packet,
"E.could not connect marker: channel=%s, name=%s",
7083 m->channel, m->name);
7087 strcpy (packet,
"OK");
7091 sprintf (packet,
"E.no marker found at 0x%s",
paddress (address));
7100 struct marker_iter iter;
7103 p +=
sizeof (
"qTSTMat:") - 1;
7107 USTF(marker_iter_reset) (&iter);
7109 for (USTF(marker_iter_start) (&iter), m = iter.marker;
7111 USTF(marker_iter_next) (&iter), m = iter.marker)
7112 if ((uintptr_t ) m->location == address)
7114 response_ust_marker (packet, m);
7118 strcpy (packet,
"l");
7128 USTF(ltt_probe_register) (&gdb_ust_probe);
7133 #include <sys/syscall.h>
7136 gdb_agent_remove_socket (
void)
7138 unlink (agent_socket_name);
7144 gdb_agent_helper_thread (
void *arg)
7148 atexit (gdb_agent_remove_socket);
7152 listen_fd = gdb_agent_socket_init ();
7154 if (helper_thread_id == 0)
7155 helper_thread_id = syscall (SYS_gettid);
7157 if (listen_fd == -1)
7159 warning (
"could not create sync socket\n");
7166 struct sockaddr_un sockaddr;
7172 tmp =
sizeof (sockaddr);
7176 fd = accept (listen_fd, (
struct sockaddr *) &sockaddr, &tmp);
7179 while (fd == -512 || (fd == -1 &&
errno == EINTR));
7183 warning (
"Accept returned %d, error: %s\n",
7190 ret = read (fd, buf, 1);
7191 }
while (ret == -1 &&
errno == EINTR);
7195 warning (
"reading socket (fd=%d) failed with %s",
7208 else if (strcmp (
"qTfSTM", cmd_buf) == 0)
7212 else if (strcmp (
"qTsSTM", cmd_buf) == 0)
7216 else if (
startswith (cmd_buf,
"unprobe_marker_at:"))
7220 else if (
startswith (cmd_buf,
"probe_marker_at:"))
7232 ret = write (fd, buf, 1);
7238 unlink (agent_socket_name);
7255 #include <pthread.h>
7262 gdb_agent_init (
void)
7272 sigfillset (&new_mask);
7273 res = pthread_sigmask (SIG_SETMASK, &new_mask, &orig_mask);
7277 res = pthread_create (&thread,
7279 gdb_agent_helper_thread,
7282 res = pthread_sigmask (SIG_SETMASK, &orig_mask, NULL);
7286 while (helper_thread_id == 0)
7294 #include <sys/mman.h>
7311 gdb_trampoline_buffer = (
char *) (uintptr_t) begin;
7312 gdb_trampoline_buffer_end = (
char *) (uintptr_t) end;
7314 strncpy (gdb_trampoline_buffer_error, errmsg, 99);
7316 strcpy (gdb_trampoline_buffer_error,
"no buffer passed");
7320 initialize_tracepoint_ftlib (
void)
7338 if (gettimeofday (&tv, 0) != 0)
7341 return (
LONGEST) tv.tv_sec * 1000000 + tv.tv_usec;
7358 #ifdef IN_PROCESS_AGENT
7363 pagesize = sysconf (_SC_PAGE_SIZE);
7367 gdb_tp_heap_buffer =
xmalloc (5 * 1024 * 1024);
7369 #define SCRATCH_BUFFER_NPAGES 20
7373 for (addr = pagesize; addr != 0; addr += pagesize)
7375 gdb_jump_pad_buffer = mmap ((
void *) addr, pagesize * SCRATCH_BUFFER_NPAGES,
7376 PROT_READ | PROT_WRITE | PROT_EXEC,
7377 MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
7379 if (gdb_jump_pad_buffer != MAP_FAILED)
7386 gdb_jump_pad_buffer_end = gdb_jump_pad_buffer + pagesize * SCRATCH_BUFFER_NPAGES;
7389 gdb_trampoline_buffer = gdb_trampoline_buffer_end = 0;
7397 strcpy (gdb_trampoline_buffer_error,
"No errors reported");
static CORE_ADDR get_jump_space_head(void)
const struct target_desc * tdesc
int handle_tracepoint_query(char *packet)
static const struct tracepoint_action_ops r_tracepoint_action_ops
#define IPA_PROTO_FAST_TRACE_FJUMP_INSN
LONGEST agent_get_trace_state_variable_value(int num)
CORE_ADDR get_set_tsv_func_addr(void)
static struct source_string * cur_source_string
static int tracing_stop_tpnum
static int tracepoint_handler(CORE_ADDR address)
struct thread_info * current_thread
struct regcache * regcache
static void cmd_qtminftpilen(char *packet)
struct source_string * source_strings
static void cmd_qtfstm(char *packet)
#define IP_AGENT_EXPORT_FUNC
static struct tracepoint * fast_tracepoint_from_ipa_tpoint_address(CORE_ADDR)
static struct trace_state_variable * create_trace_state_variable(int num, int gdb)
CORE_ADDR addr_gdb_jump_pad_buffer_end
IP_AGENT_EXPORT_VAR unsigned int traceframe_write_count
CORE_ADDR addr_get_raw_reg
CORE_ADDR addr_tracepoints
static unsigned char * traceframe_find_block_type(unsigned char *database, unsigned int datasize, int tfnum, char type_wanted)
int fetch_traceframe_registers(int tfnum, struct regcache *regcache, int regnum)
#define target_get_min_fast_tracepoint_insn_len()
static struct traceframe * find_next_traceframe_by_tracepoint(int num, int *tfnump)
#define install_fast_tracepoint_jump_pad(tpoint, tpaddr,collector, lockaddr,orig_size,jump_entry,trampoline, trampoline_size, jjump_pad_insn,jjump_pad_insn_size,adjusted_insn_addr,adjusted_insn_addr_end, err)
EXTERN_C_PUSH IP_AGENT_EXPORT_VAR struct tracepoint * tracepoints
static void cmd_qtframe(char *own_buf)
struct collecting_t collecting_t
int agent_look_up_symbols(void *arg)
IP_AGENT_EXPORT_VAR unsigned int traceframe_read_count
static void write_e_ust_not_loaded(char *buffer)
#define target_emit_ops()
#define IPA_FIRST_TRACEFRAME()
static int traceframe_read_tsv(int num, LONGEST *val)
static struct trace_state_variable * get_trace_state_variable(int num)
#define cmpxchg(mem, oldval, newval)
static struct readonly_region * readonly_regions
#define unpause_all(unfreeze)
static void cmd_qtv(char *own_buf)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
struct trace_state_variable * next
void warning(const char *fmt,...)
CORE_ADDR addr_traceframe_write_count
static CORE_ADDR get_traceframe_address(struct traceframe *tframe)
static const struct tracepoint_action_ops l_tracepoint_action_ops
static void cmd_qtnotes(char *own_buf)
CORE_ADDR addr_trace_buffer_is_full
static int read_inferior_data_pointer(CORE_ADDR symaddr, CORE_ADDR *val)
static int same_process_p(struct inferior_list_entry *entry, void *data)
static unsigned int cur_action
static struct tracepoint * fast_tracepoint_from_trampoline_address(CORE_ADDR pc)
struct tracepoint_action base
static void cmd_qtdisconnected(char *own_buf)
char * plongest(LONGEST l)
int bin2hex(const gdb_byte *bin, char *hex, int count)
const struct tracepoint_action_ops * ops
static unsigned char * traceframe_find_regblock(struct traceframe *tframe, int tfnum)
static void write_e_ipa_not_loaded(char *buffer)
static CORE_ADDR target_tp_heap
CORE_ADDR addr_trace_buffer_hi
#define IP_AGENT_EXPORT_VAR
CORE_ADDR adjusted_insn_addr_end
void initialize_tracepoint(void)
void internal_error(const char *file, int line, const char *fmt,...)
IP_AGENT_EXPORT_FUNC LONGEST get_trace_state_variable_value(int num)
static void cmd_qtsv(char *packet)
int agent_mem_read(struct eval_agent_expr_context *ctx, unsigned char *to, CORE_ADDR from, ULONGEST len)
enum eval_result_type compile_bytecodes(struct agent_expr *aexpr)
CORE_ADDR adjusted_insn_addr
static void record_tracepoint_error(struct tracepoint *tpoint, const char *which, enum eval_result_type rtype)
static void do_action_at_tracepoint(struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, struct tracepoint *tpoint, struct traceframe *tframe, struct tracepoint_action *taction)
static void cmd_qtsp(char *packet)
#define DEFAULT_TRACE_BUFFER_SIZE
char * paddress(CORE_ADDR addr)
CORE_ADDR addr_traceframe_read_count
struct tracepoint_action base
#define NEXT_TRACEFRAME(TF)
IP_AGENT_EXPORT_VAR enum eval_result_type expr_eval_result
static void clear_trace_buffer(void)
#define trace_buffer_end_free
struct wstep_state * while_stepping
static void init_trace_buffer(LONGEST bufsize)
void agent_set_trace_state_variable_value(int num, LONGEST val)
struct readonly_region * next
static void clear_readonly_regions(void)
IP_AGENT_EXPORT_VAR struct tracepoint * stopping_tracepoint
static int tracepoint_send_agent(struct tracepoint *tpoint)
static char * agent_expr_send(char *p, const struct agent_expr *aexpr)
static char * m_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
CORE_ADDR addr_set_trace_state_variable_value
void uninsert_all_breakpoints(void)
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
static char * x_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
void reinsert_all_breakpoints(void)
#define GDBSERVER_UPDATED_FLUSH_COUNT_BIT
enum eval_result_type(* condfn)(struct tracepoint_hit_ctx *, ULONGEST *)
char *(* send)(char *buffer, const struct tracepoint_action *action)
struct inferior_list_entry entry
static struct @5 symbol_list[]
static int circular_trace_buffer
#define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD)
#define IPA_PROTO_FAST_TRACE_FJUMP_SIZE
int tracepoint_was_hit(struct thread_info *tinfo, CORE_ADDR stop_pc)
static int write_inferior_data_pointer(CORE_ADDR symaddr, CORE_ADDR val)
int agent_run_command(int pid, const char *cmd, int len)
static int probe_marker_at(CORE_ADDR address, char *errout)
CORE_ADDR addr_ust_loaded
struct tracepoint_action base
static void download_tracepoint_1(struct tracepoint *tpoint)
int agent_tsv_read(struct eval_agent_expr_context *ctx, int n)
static const struct tracepoint_action_ops m_tracepoint_action_ops
CORE_ADDR addr_stopping_tracepoint
struct pt_watch_regs __attribute__
int handle_tracepoint_bkpts(struct thread_info *tinfo, CORE_ADDR stop_pc)
static struct tracepoint * find_next_tracepoint_by_number(struct tracepoint *prev_tp, int num)
static CORE_ADDR gdb_jump_pad_head
int agent_mem_read_string(struct eval_agent_expr_context *ctx, unsigned char *to, CORE_ADDR from, ULONGEST len)
static void claim_jump_space(ULONGEST used)
#define trace_buffer_start
static int match_blocktype(char blocktype, unsigned char *dataptr, void *data)
int fast_tracepoint_collecting(CORE_ADDR thread_area, CORE_ADDR stop_pc, struct fast_tpoint_collect_status *status)
CORE_ADDR addr_gdb_trampoline_buffer_end
static const struct tracepoint_action_ops x_tracepoint_action_ops
static CORE_ADDR trampoline_buffer_tail
void release_while_stepping_state_list(struct thread_info *tinfo)
static LONGEST get_timestamp(void)
struct tracepoint_hit_ctx base
static int write_inferior_integer(CORE_ADDR symaddr, int val)
static void finish_traceframe(struct traceframe *tframe)
void buffer_xml_printf(struct buffer *buffer, const char *format,...)
CORE_ADDR current_insn_ptr
IP_AGENT_EXPORT_FUNC void set_trace_state_variable_value(int num, LONGEST val)
static void * trace_buffer_alloc(size_t amt)
static int maybe_write_ipa_ust_not_loaded(char *buffer)
CORE_ADDR addr_gdb_tp_heap_buffer
int in_readonly_region(CORE_ADDR addr, ULONGEST length)
static void collect_data_at_tracepoint(struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, struct tracepoint *tpoint)
IP_AGENT_EXPORT_VAR int traceframes_created
CORE_ADDR addr_trace_buffer_ctrl
static uint32_t helper_thread_id
struct callback_event * last
int read_inferior_memory(CORE_ADDR memaddr, unsigned char *myaddr, int len)
static void clear_inferior_trace_buffer(void)
CORE_ADDR addr_gdb_collect
CORE_ADDR addr_gdb_jump_pad_buffer
static void set_trace_state_variable_name(int num, const char *name)
static void cmd_qtfv(char *packet)
static int flush_trace_buffer_handler(CORE_ADDR)
static void add_tracepoint_action(struct tracepoint *tpoint, char *packet)
CORE_ADDR(* download)(const struct tracepoint_action *action)
struct tracepoint * tpoint
static void cmd_qtdpsrc(char *own_buf)
int handle_tracepoint_general_set(char *packet)
char * pulongest(ULONGEST u)
static unsigned int cur_step_action
int look_up_one_symbol(const char *name, CORE_ADDR *addrp, int may_ask_gdb)
static CORE_ADDR trampoline_buffer_head
#define done_accessing_memory()
CORE_ADDR addr_expr_eval_result
EXTERN_C_PUSH IP_AGENT_EXPORT_VAR struct tracepoint * error_tracepoint
static EXTERN_C_POP struct tracepoint * last_tracepoint
void tracepoint_look_up_symbols(void)
static void response_action(char *packet, struct tracepoint *tpoint, char *taction, int step)
int traceframe_read_info(int tfnum, struct buffer *buffer)
static int condition_true_at_tracepoint(struct tracepoint_hit_ctx *ctx, struct tracepoint *tpoint)
static int free_space(void)
void regcache_cpy(struct regcache *dst, struct regcache *src)
static void clone_fast_tracepoint(struct tracepoint *to, const struct tracepoint *from)
struct source_string * next
static CORE_ADDR download_agent_expr(struct agent_expr *expr)
static void cmd_qtsstm(char *packet)
static void compile_tracepoint_condition(struct tracepoint *tpoint, CORE_ADDR *jump_entry)
static int startswith(const char *string, const char *pattern)
int register_cache_size(const struct target_desc *tdesc)
struct trace_buffer_control trace_buffer_ctrl[1]
enum eval_result_type gdb_eval_agent_expr(struct eval_agent_expr_context *ctx, struct agent_expr *aexpr, ULONGEST *rslt)
#define GDBSERVER_FLUSH_COUNT_MASK_PREV
static void cmd_qtstatus(char *packet)
static void cmd_qtro(char *own_buf)
CORE_ADDR obj_addr_on_target
static struct tracepoint * fast_tracepoint_from_jump_pad_address(CORE_ADDR pc)
CORE_ADDR addr_gdb_trampoline_buffer_error
static void set_trace_state_variable_getter(int num, LONGEST(*getter)(void))
static void release_while_stepping_state(struct wstep_state *wstep)
static int maybe_write_ipa_not_loaded(char *buffer)
CORE_ADDR addr_traceframes_created
static struct tracepoint * find_tracepoint(int id, CORE_ADDR addr)
char * unpack_varlen_hex(char *buff, ULONGEST *result)
struct breakpoint * flush_trace_buffer_bkpt
static struct tracepoint * cur_tpoint
struct tracepoint_action ** actions
struct traceframe * tframe
static void cmd_qtstop(char *packet)
struct breakpoint * stop_tracing_bkpt
#define GDBSERVER_FLUSH_COUNT_MASK
static void cmd_qtinit(char *packet)
#define TRACEFRAME_EOB_MARKER_SIZE
#define buffer_grow_str(BUFFER, STRING)
struct inferior_list all_threads
struct tracepoint_action base
static LONGEST trace_buffer_size
#define prepare_to_access_memory()
static void remove_tracepoint(struct tracepoint *tpoint)
static CORE_ADDR target_malloc(ULONGEST size)
struct fast_tracepoint_jump * set_fast_tracepoint_jump(CORE_ADDR where, unsigned char *insn, ULONGEST length)
static void cmd_qtbuffer(char *own_buf)
int have_fast_tracepoint_trampoline_buffer(char *buf)
int agent_capability_check(enum agent_capa agent_capa)
static void cmd_qtstmat(char *packet)
static void clear_installed_tracepoints(void)
static int seen_step_action_flag
struct agent_expr * gdb_parse_agent_expr(char **actparm)
static unsigned char * traceframe_walk_blocks(unsigned char *database, unsigned int datasize, int tfnum, int(*callback)(char blocktype, unsigned char *dataptr, void *data), void *data)
#define stabilize_threads()
int write_inferior_memory(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
int ptid_get_pid(ptid_t ptid)
static void ATTRIBUTE_PRINTF(1, 2)
LONGEST tracing_start_time
PTR xrealloc(PTR ptr, size_t size)
static struct traceframe * find_traceframe(int num)
static struct traceframe * find_next_traceframe_in_range(CORE_ADDR lo, CORE_ADDR hi, int inside_p, int *tfnump)
IP_AGENT_EXPORT_VAR int trace_buffer_is_full
static CORE_ADDR x_tracepoint_action_download(const struct tracepoint_action *action)
struct regcache * init_register_cache(struct regcache *regcache, const struct target_desc *tdesc, unsigned char *regbuf)
#define buffer_grow_str0(BUFFER, STRING)
CORE_ADDR addr_gdb_trampoline_buffer
CORE_ADDR addr_trace_buffer_lo
#define trace_buffer_free
char * phex_nz(ULONGEST l, int sizeof_l)
int claim_trampoline_space(ULONGEST used, CORE_ADDR *trampoline)
#define pause_all(freeze)
static void cmd_qtdv(char *own_buf)
void force_unlock_trace_buffer(void)
static void cmd_qtenable_disable(char *own_buf, int enable)
uint64_t traceframe_usage
struct wstep_state * next
const struct target_desc * current_target_desc(void)
int tracepoint_finished_step(struct thread_info *tinfo, CORE_ADDR stop_pc)
int xsnprintf(char *str, size_t size, const char *format,...)
CORE_ADDR addr_flush_trace_buffer
static void cmd_bigqtbuffer_size(char *own_buf)
static CORE_ADDR l_tracepoint_action_download(const struct tracepoint_action *action)
CORE_ADDR get_raw_reg_func_addr(void)
const char * target_pid_to_str(ptid_t ptid)
static void cmd_qtp(char *own_buf)
static void response_source(char *packet, struct tracepoint *tpoint, struct source_string *src)
static int read_inferior_uinteger(CORE_ADDR symaddr, unsigned int *val)
static struct regcache * get_context_regcache(struct tracepoint_hit_ctx *ctx)
static void install_tracepoint(struct tracepoint *, char *own_buf)
static void cmd_qtstart(char *packet)
static int read_inferior_integer(CORE_ADDR symaddr, int *val)
static struct tracepoint * add_tracepoint(int num, CORE_ADDR addr)
struct regcache * get_thread_regcache(struct thread_info *thread, int fetch)
void initialize_low_tracepoint(void)
static void response_tsv(char *packet, struct trace_state_variable *tsv)
CORE_ADDR adjusted_insn_addr
IP_AGENT_EXPORT_VAR int tracing
static void response_tracepoint(char *packet, struct tracepoint *tpoint)
void perror_with_name(const char *string)
static unsigned char * add_traceframe_block(struct traceframe *tframe, struct tracepoint *tpoint, int amt)
static int build_traceframe_info_xml(char blocktype, unsigned char *dataptr, void *data)
int delete_fast_tracepoint_jump(struct fast_tracepoint_jump *todel)
static void unprobe_marker_at(CORE_ADDR address)
struct tracepoint_action ** step_actions
static void cmd_bigqtbuffer_circular(char *own_buf)
static CORE_ADDR traceframe_get_pc(struct traceframe *tframe)
CORE_ADDR addr_about_to_request_buffer_space
#define trace_debug(FMT, args...)
IP_AGENT_EXPORT_VAR unsigned char * trace_buffer_hi
unsigned long long ULONGEST
static void download_trace_state_variables(void)
char * gdb_unparse_agent_expr(struct agent_expr *aexpr)
EXTERN_C_PUSH IP_AGENT_EXPORT_VAR unsigned char * trace_buffer_lo
char * savestring(const char *ptr, size_t len)
CORE_ADDR adjusted_insn_addr_end
CORE_ADDR addr_get_trace_state_variable_value
static struct traceframe * add_traceframe(struct tracepoint *tpoint)
struct breakpoint * set_breakpoint_at(CORE_ADDR where, int(*handler)(CORE_ADDR))
IP_AGENT_EXPORT_VAR struct trace_state_variable * trace_state_variables
void inc_ref_fast_tracepoint_jump(struct fast_tracepoint_jump *jp)
static int install_fast_tracepoint(struct tracepoint *, char *errbuf)
int hex2bin(const char *hex, gdb_byte *bin, int count)
#define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET
#define trace_buffer_wrap
#define GDBSERVER_FLUSH_COUNT_MASK_CURR
CORE_ADDR get_get_tsv_func_addr(void)
static int write_inferior_uinteger(CORE_ADDR symaddr, unsigned int val)
static char * r_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
#define IPA_PROTO_FAST_TRACE_JUMP_PAD
void gdb_agent_about_to_close(int pid)
static void cmd_qtdp(char *own_buf)
void debug_printf(const char *fmt,...)
static void collect_data_at_step(struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, struct tracepoint *tpoint, int current_step)
CORE_ADDR addr_stop_tracing
enum tracepoint_type type
#define IPA_NEXT_TRACEFRAME(TF, TFOBJ)
CORE_ADDR addr_error_tracepoint
int traceframe_read_sdata(int tfnum, ULONGEST offset, unsigned char *buf, ULONGEST length, ULONGEST *nbytes)
static void download_tracepoint(struct tracepoint *)
static void add_while_stepping_state(struct thread_info *tinfo, int tp_number, CORE_ADDR tp_address)
static void cmd_qtfp(char *packet)
static int run_inferior_command(char *cmd, int len)
static struct trace_state_variable * cur_tsv
static char * l_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
static CORE_ADDR m_tracepoint_action_download(const struct tracepoint_action *action)
struct regcache * regcache
static void upload_fast_traceframes(void)
static int stop_tracing_handler(CORE_ADDR)
CORE_ADDR addr_trace_buffer_ctrl_curr
void error(const char *fmt,...)
int delete_breakpoint(struct breakpoint *todel)
int traceframe_read_mem(int tfnum, CORE_ADDR addr, unsigned char *buf, ULONGEST length, ULONGEST *nbytes)
void supply_fast_tracepoint_registers(struct regcache *regcache, const unsigned char *buf)
static struct ipa_sym_addresses ipa_sym_addrs
static CORE_ADDR r_tracepoint_action_download(const struct tracepoint_action *action)
CORE_ADDR addr_collecting
void write_enn(char *buf)
void supply_regblock(struct regcache *regcache, const void *buf)
struct inferior_list_entry * find_inferior(struct inferior_list *list, int(*func)(struct inferior_list_entry *, void *), void *arg)
enum tracepoint_type type
#define FIRST_TRACEFRAME()
static int in_process_agent_supports_ust(void)
static int write_inferior_data_ptr(CORE_ADDR where, CORE_ADDR ptr)
LONGEST tracing_stop_time
CORE_ADDR addr_trace_state_variables