This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Static tracepoints support
- From: Pedro Alves <pedro at codesourcery dot com>
- To: gdb-patches at sourceware dot org
- Date: Fri, 25 Jun 2010 19:31:56 +0100
- Subject: Static tracepoints support
This patch adds static tracepoints support to GDB, and adds GDBserver
support for LTTng/UST based static tracepoints <http://lttng.org/ust>.
We worked activelly with the LTTng/UST maintainers to design
and implement this integration.
(NEWS and manual changes included. Are those okay?)
The use case for static tracepoints is different from fast and trap
based tracepoints, which are dynamic tracepoints (versus static).
With static tracing, a set of instrumentation points, also known as
markers, are embedded in the target program, put there by the
developers most familiar with the tracee system, and can be activated
or deactivated by name or address. These are usually placed at
locations which facilitate investigating what the target is actually
doing. GDB's new support for static tracing includes being able to
list instrumentation points, and probe them with GDB defined high
level tracepoints that expose the whole range of convenience of GDB's
tracepoints support. Namelly, support for collecting registers values
and values of global or local (to the instrumentation point)
variables; tracepoint conditions and trace state variables.
UST in a nutshell: an LTTng/UST marker is roughly the tracepoint call
in the user code. These markers can be instrumented or not. The act
of instrumenting a marker is to connect a probe to it. A marker
without probes connected is a disabled marker. LTTng/UST has this
clever mechanism to make disabled marker calls be quite efficient.
A new command "info static-tracepoint-markers" was added to be able to
list the set of markers. Example:
(gdb) info static-tracepoint-markers
Enb Address What
n 0x00007ffff7996692
String ID: metadata/core_marker_format
Extra: channel %s name %s format %s
n 0x00007ffff7997897
String ID: metadata/core_marker_format
Extra: channel %s name %s format %s
n 0x00007ffff799857d
String ID: metadata/core_marker_id
Extra: channel %s name %s event_id %hu int #1u%zu long #1u%zu pointer #1u%zu size_t #1u%zu alignment #1u%u
n 0x00007ffff7998a04
String ID: metadata/core_marker_id
Extra: channel %s name %s event_id %hu int #1u%zu long #1u%zu pointer #1u%zu size_t #1u%zu alignment #1u%u
n 0x00007ffff799a006
String ID: metadata/core_marker_id
Extra: channel %s name %s event_id %hu int #1u%zu long #1u%zu pointer #1u%zu size_t #1u%zu alignment #1u%u
n 0x00007ffff799a235
String ID: metadata/core_marker_format
Extra: channel %s name %s format %s
n 0x00007ffff79b7240
String ID: ust/potential_exec
Extra:
n 0x0000000000400c68 in main at stexample.c:21
String ID: ust/bar2
Extra: number1 %d number2 %d
n 0x0000000000400ddc in main at stexample.c:20
String ID: ust/bar33
Extra: str %s
n 0x0000000000400f84
String ID: ust/dummymark
Extra:
(gdb)
The "What" column is similar to the "info breakpoints" output, and
shows the source location of the marker, if possible. This is
inferred from the PC each marker is attached to, as reported by the
static tracing library / GDBserver. The "Enabled" column tells us in
a quick look if the marker is probed.
When probed, the column shows "y", and a new line appears in the
output showing which GDB static tracepoints are probing it. More on
that in a bit. Here's what it looks like:
y 0x0000000000400ddc in main at stexample.c:20
String ID: ust/bar33
Extra: str %s
Probed by static tracepoints: #2
Each marker has an unique string ID, as can be seen above. In UST,
this ID is specified by the user. Here's the probe point
corresponding to the marker shown above:
trace_mark (ust, bar33, "str %s", "FOOBAZ");
Note that this is similar to a printf call --- "str %s" is a
printf-like formatter string, and "FOOBAZ" is the argument to fill in
%s. When using UST standalone, without GDB, this is the data you can
collect at this probe point, using UST's own instrumentation probes.
The result of this "printf", is what we call static tracepoint data.
The "Extra" bit you see in the listing above, corresponds to that
format string in UST. More on that below.
To staple a GDB tracepoint on one of those markers, one uses the new
"strace" command (yes, it can be confused with the strace utility; it
was the natural obvious choice after "trace" and "ftrace" for fast
tracepoints; a good alternative spelling suggestion is welcome). To
collect the static tracepoint data in GDBserver's trace buffer, we use
the new "collect $_sdata" action.
Here's a more complete example:
11 int
12 main ()
13 {
14 printf("Basic test program\n");
15
16 while (1)
17 {
18
19
20 trace_mark(ust, bar33, "str %s", "FOOBAZ");
21 trace_mark(ust, bar2, "number1 %d number2 %d", 53, 9800);
22 usleep(100000);
23 }
24
25 return 0;
26 }
This example corresponds to the earlier "info static-tracepoint-markers"
output. To recap, lines 20 and 21 would be listed as following
markers:
n 0x0000000000400c68 in main at stexample.c:21
String ID: ust/bar2
Extra: number1 %d number2 %d
n 0x0000000000400ddc in main at stexample.c:20
String ID: ust/bar33
Extra: str %s
So, to probe the markers and make them actually collect something, we
do:
(gdb) strace stexample.c:20
Probed static tracepoint marker "ust/bar33"
Static tracepoint 2 at 0x400ddc: file stexample.c, line 20.
(gdb) actions
Enter actions for tracepoint 2, one per line.
End with a line saying just "end".
>collect $registers
>collect $_sdata
>end
(gdb) info breakpoints
Num Type Disp Enb Address What
1 breakpoint keep y 0x0000000000400c30 in main at stexample.c:13
2 static tracepoint keep y 0x0000000000400ddc in main at stexample.c:20
static tracepoint id is ust/bar33
collect $registers
collect $_sdata
(gdb) tstart
(gdb) c
Continuing.
^C
Program received signal SIGINT, Interrupt.
0x00007ffff76b635d in nanosleep () from /lib/libc.so.6
(gdb) tstop
And to see the UST data, we do:
(gdb) tfind
Found trace frame 0, tracepoint 2
20 trace_mark(ust, bar33, "str %s", "FOOBAZ");
(gdb) p $_sdata
$1 = "str=FOOBAZ"
Since we've collected registers as well, we can see the values of the
registers at the time of the tracepoint "hit", with the regular "info
registers", etc., commands. If we add "collect $locals" to the action
list, we could inspect the values of the locals, and so on. This is
the main advantage of marrying gdb tracepoints with a static
tracepoints library.
Implementation wise, remember that when we're analysing the trace
buffer (tfind mode), the data in on the target side. To be able to
transfer the $_sdata object from the target to GDB, I've added a new
TARGET_OBJECT_STATIC_TRACE_DATA object, and implemented a new
"qXfer:statictrace:read:" remote packet.
You can also install a gdb tracepoint on top of marker by marker id.
You do that with "strace -m" (m for marker). Example:
(gdb) strace -m ust/bar2
Probed static tracepoint marker "ust/bar2"
Static tracepoint 4 at 0x400c68: file stexample.c, line 21.
UST exposes an API that allows querying the list of markers, and
probe them. "Probing" roughly means that we're interested in having
a provided callback called whenever the program passed by the marker.
GDBserver's new in-process agent library implements such an UST
probe, and deals with UST API. GDBserver then interfaces with UST
by means of interfacing with the in-process agent library.
This is the last piece of gdbserver tracepoints work that I
had aimed at 7.2...
2010-06-25 Pedro Alves <pedro@codesourcery.com>
gdb/gdbserver/
* configure.ac: Handle --with-ust. substitute ustlibs and ustinc.
* mem-break.c (uninsert_all_breakpoints)
(reinsert_all_breakpoints): New.
* mem-break.h (reinsert_all_breakpoints, uninsert_all_breakpoints):
* tracepoint.c (ust_loaded, helper_thread_id, cmd_buf): New.
(gdb_agent_ust_loaded, helper_thread_id)
(gdb_agent_helper_thread_id): New macros.
(struct ipa_sym_addresses): Add addr_ust_loaded,
addr_helper_thread_id, addr_cmd_buf.
(symbol_list): Add ust_loaded, helper_thread_id, cmd_buf.
(in_process_agent_loaded_ust): New.
(write_e_ust_not_loaded): New.
(maybe_write_ipa_ust_not_loaded): New.
(struct collect_static_trace_data_action): New.
(enum tracepoint_type) <static_tracepoint>: New.
(struct tracepoint) <handle>: Mention static tracepoints.
(struct static_tracepoint_ctx): New.
(CMD_BUF_SIZE): New.
(add_tracepoint_action): Handle static tracepoint actions.
(unprobe_marker_at): New.
(clear_installed_tracepoints): Handle static tracepoints.
(cmd_qtdp): Handle static tracepoints.
(probe_marker_at): New.
(cmd_qtstart): Handle static tracepoints.
(response_tracepoint): Handle static tracepoints.
(cmd_qtfstm, cmd_qtsstm, cmd_qtstmat): New.
(handle_tracepoint_query): Handle qTfSTM, qTsSTM and qTSTMat.
(get_context_regcache): Handle static tracepoints.
(do_action_at_tracepoint): Handle static tracepoint actions.
(traceframe_find_block_type): Handle static trace data blocks.
(traceframe_read_sdata): New.
(download_tracepoints): Download static tracepoint actions.
[HAVE_UST] Include ust/ust.h, dlfcn.h, sys/socket.h, and sys/un.h.
(GDB_PROBE_NAME): New.
(ust_ops): New.
(GET_UST_SYM): New.
(USTF): New.
(dlsym_ust): New.
(ust_marker_to_static_tracepoint): New.
(gdb_probe): New.
(collect_ust_data_at_tracepoint): New.
(gdb_ust_probe): New.
(UNIX_PATH_MAX, SOCK_DIR): New.
(gdb_ust_connect_sync_socket): New.
(resume_thread, stop_thread): New.
(run_inferior_command): New.
(init_named_socket): New.
(gdb_ust_socket_init): New.
(cstr_to_hexstr): New.
(next_st): New.
(first_marker, next_marker): New.
(response_ust_marker): New.
(cmd_qtfstm, cmd_qtsstm): New.
(unprobe_marker_at, probe_marker_at): New.
(cmd_qtstmat, gdb_ust_thread): New.
(gdb_ust_init): New.
(initialize_tracepoint_ftlib): Call gdb_ust_init.
* linux-amd64-ipa.c [HAVE_UST]: Include ust/processor.h
(ST_REGENTRY): New.
(x86_64_st_collect_regmap): New.
(X86_64_NUM_ST_COLLECT_GREGS): New.
(AMD64_RIP_REGNUM): New.
(supply_static_tracepoint_registers): New.
* linux-i386-ipa.c [HAVE_UST]: Include ust/processor.h
(ST_REGENTRY): New.
(i386_st_collect_regmap): New.
(i386_NUM_ST_COLLECT_GREGS): New.
(supply_static_tracepoint_registers): New.
* server.c (handle_query): Handle qXfer:statictrace:read.
<qSupported>: Report support for StaticTracepoints, and
qXfer:statictrace:read features.
* server.h (traceframe_read_sdata)
(supply_static_tracepoint_registers): Declare.
* remote-utils.c (convert_int_to_ascii, hexchars, ishex, tohex)
(unpack_varlen_hex): Include in IPA build.
* Makefile.in (IPA_OBJS): Add remote-utils-ipa.o.
* config.in, configure: Regenerate.
gdb/
* NEWS: Mention new support for static tracepoints.
(New packets): Mention qTfSTM, qTsSTM, qTSTMat and
qXfer:statictrace:read.
(New features in the GDB remote stub, GDBserver): Mention static
tracepoints support using an UST based backend.
(New commands): Mention "info static-tracepoint-markers" and
"strace".
* breakpoint.c (is_tracepoint): Handle static tracepoints.
(validate_commands_for_breakpoint): Static tracepoints can't do
while-stepping.
(static_tracepoints_here): New.
(bpstat_what): Handle static tracepoints.
(print_one_breakpoint_location, allocate_bp_location, mention):
Ditto.
(create_breakpoint_sal): Ditto.
(decode_static_tracepoint_spec): New.
(create_breakpoint): Replace `hardwareflag', and `traceflag' with
`type_wanted'. Adjust. Handle static tracepoint marker
locations.
(break_command_1): Adjust.
(update_static_tracepoint): New.
(update_breakpoint_locations): Handle static tracepoints.
(breakpoint_re_set_one): Handle static tracepoint marker
locations.
(disable_command, enable_command): Handle static tracepoints.
(trace_command, ftrace_command): Adjust.
(strace_command): New.
(create_tracepoint_from_upload): Adjust.
(save_breakpoints): Handle static tracepoints.
(_initialize_breakpoint): Install the "strace" command.
* breakpoint.h (enum bptype): New bp_static_tracepoint type.
(struct breakpoint): New field static_trace_id.
(breakpoints_here_p): Declare.
(create_breakpoint): Adjust.
(static_tracepoints_here): Declare.
* remote.c (struct remote_state) <static_tracepoints>: New field.
(PACKET_qXfer_statictrace_read, PACKET_StaticTracepoints): New.
(remote_static_tracepoint_marker_at): New.
(remote_static_tracepoint_marker_by_strid): New.
(remote_list_static_tracepoint_markers): New.
(remote_static_tracepoint_feature): New.
(remote_disconnected_tracing_feature): Handle "StaticTracepoints".
(remote_xfer_partial): Handle TARGET_OBJECT_STATIC_TRACE_DATA.
(remote_supports_static_tracepoints): New.
(remote_download_tracepoint): Download static tracepoints.
(init_remote_ops): Install remote_list_static_tracepoint_markers,
remote_static_tracepoint_marker_at and
remote_static_tracepoint_marker_by_strid.
(_initialize_remote): Install set|show remote static-tracepoints,
and set|show remote read-static-trace-object commands.
* target.c (update_current_target): Inherit and default
to_list_static_tracepoint_markers, to_static_tracepoint_marker_at,
to_static_tracepoint_marker_by_strid.
* target.h (static_tracepoint_marker): Forward declare.
(enum target_object): New object TARGET_OBJECT_STATIC_TRACE_DATA.
(struct target_ops): New fields to_list_static_tracepoint_markers,
to_static_tracepoint_marker_at,
to_static_tracepoint_marker_by_strid.
(target_list_static_tracepoint_markers)
(target_static_tracepoint_marker_at)
(target_static_tracepoint_marker_by_strid): New.
* tracepoint.c: Include source.h.
(validate_actionline): Handle $_sdata.
(struct collection_list): New field strace_data.
(add_static_trace_data): New.
(clear_collection_list): Clear strace_data.
(stringify_collection_list): Account for a possible static trace
data collection.
(encode_actions_1): Encode an $_sdata collection.
(parse_tracepoint_definition): Handle static tracepoints.
(parse_static_tracepoint_marker_definition): New.
(release_static_tracepoint_marker): New.
(print_one_static_tracepoint_marker): New.
(info_static_tracepoint_markers_command): New.
(sdata_make_value): New.
(_initialize_tracepoint): Create the $_sdata convenience variable.
Add the "info static-tracepoint-markers" command.
Mention $_sdata in the "collect" command's help output.
* tracepoint.h (struct static_tracepoint_marker): New.
(parse_static_tracepoint_marker_definition)
(print_one_static_tracepoint_marker)
(release_static_tracepoint_marker): Declare.
* mi/mi-cmd-break.c (mi_cmd_break_insert): Adjust.
* python/py-breakpoint.c (bppy_new): Adjust.
doc/
* gdb.texinfo (Convenience Variables): Document $_sdata.
(Commands to Set Tracepoints): Describe static tracepoints. Add
`Listing Static Tracepoint Markers' menu entry. Document
"strace".
(Tracepoint Action Lists): Document collecting $_sdata.
(Listing Static Tracepoint Markers): New subsection.
(Tracepoints support in gdbserver): Mention static tracepoints.
(remote packets, enabling and disabling): Mention
read-sdata-object.
(General Query Packets) <qSupported>: Document qXfer:sdata:read
and StaticTracepoint.
Mention qTfSTM, qTsSTM and qTSTMat as tracepoint packets.
Document qXfer:sdata:read.
(Tracepoint packets): Document qTfSTM, qTsSTM and qTSTMat.
---
gdb/NEWS | 69 +-
gdb/breakpoint.c | 329 +++++++++-
gdb/breakpoint.h | 13
gdb/doc/gdb.texinfo | 181 +++++
gdb/gdbserver/Makefile.in | 2
gdb/gdbserver/config.in | 3
gdb/gdbserver/configure | 104 +++
gdb/gdbserver/configure.ac | 48 +
gdb/gdbserver/linux-amd64-ipa.c | 89 ++
gdb/gdbserver/linux-i386-ipa.c | 77 ++
gdb/gdbserver/mem-break.c | 22
gdb/gdbserver/mem-break.h | 11
gdb/gdbserver/remote-utils.c | 19
gdb/gdbserver/server.c | 48 +
gdb/gdbserver/server.h | 7
gdb/gdbserver/tracepoint.c | 1269 +++++++++++++++++++++++++++++++++++++++-
gdb/mi/mi-cmd-break.c | 15
gdb/python/py-breakpoint.c | 2
gdb/remote.c | 160 +++++
gdb/target.c | 12
gdb/target.h | 27
gdb/tracepoint.c | 276 ++++++++
gdb/tracepoint.h | 20
23 files changed, 2735 insertions(+), 68 deletions(-)
Index: src/gdb/gdbserver/configure.ac
===================================================================
--- src.orig/gdb/gdbserver/configure.ac 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/configure.ac 2010-06-25 12:01:29.000000000 +0100
@@ -45,6 +45,54 @@ AC_CHECK_HEADERS(sgtty.h termio.h termio
AC_CHECK_FUNCS(pread pwrite pread64)
AC_REPLACE_FUNCS(memmem)
+# Check for UST
+ustlibs=""
+ustinc=""
+
+AC_ARG_WITH(ust, [ --with-ust=PATH Specify prefix directory for the installed UST package
+ Equivalent to --with-ust-include=PATH/include
+ plus --with-ust-lib=PATH/lib])
+AC_ARG_WITH(ust_include, [ --with-ust-include=PATH Specify directory for installed UST include files])
+AC_ARG_WITH(ust_lib, [ --with-ust-lib=PATH Specify the directory for the installed UST library])
+
+case $with_ust in
+ no)
+ ustlibs=
+ ustinc=
+ ;;
+ "" | yes)
+ ustlibs=" -lust "
+ ustinc=""
+ ;;
+ *)
+ ustlibs="-L$with_ust/lib -lust"
+ ustinc="-I$with_ust/include "
+ ;;
+esac
+if test "x$with_ust_include" != x; then
+ ustinc="-I$with_ust_include "
+fi
+if test "x$with_ust_lib" != x; then
+ ustlibs="-L$with_ust_lib -lust"
+fi
+
+if test "x$with_ust" != "xno"; then
+ saved_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS $ustinc"
+ AC_MSG_CHECKING([for ust])
+ AC_TRY_COMPILE([
+#define CONFIG_UST_GDB_INTEGRATION
+#include <ust/ust.h>
+ ],[],
+ [AC_MSG_RESULT([yes]); AC_DEFINE(HAVE_UST, 1, [Define if UST is available])],
+ [AC_MSG_RESULT([no]); ustlibs= ; ustinc= ])
+ CFLAGS="$saved_CFLAGS"
+fi
+
+# Flags needed for UST
+AC_SUBST(ustlibs)
+AC_SUBST(ustinc)
+
dnl dladdr is glibc-specific. It is used by thread-db.c but only for
dnl debugging messages. It lives in -ldl which is handled below so we don't
dnl use AC_CHECK_LIB (or AC_SEARCH_LIBS) here. Instead we just temporarily
Index: src/gdb/gdbserver/mem-break.c
===================================================================
--- src.orig/gdb/gdbserver/mem-break.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/mem-break.c 2010-06-25 12:01:29.000000000 +0100
@@ -777,6 +777,17 @@ uninsert_breakpoints_at (CORE_ADDR pc)
uninsert_raw_breakpoint (bp);
}
+void
+uninsert_all_breakpoints (void)
+{
+ struct process_info *proc = current_process ();
+ struct raw_breakpoint *bp;
+
+ for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+ if (bp->inserted)
+ uninsert_raw_breakpoint (bp);
+}
+
static void
reinsert_raw_breakpoint (struct raw_breakpoint *bp)
{
@@ -817,6 +828,17 @@ reinsert_breakpoints_at (CORE_ADDR pc)
}
void
+reinsert_all_breakpoints (void)
+{
+ struct process_info *proc = current_process ();
+ struct raw_breakpoint *bp;
+
+ for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+ if (!bp->inserted)
+ reinsert_raw_breakpoint (bp);
+}
+
+void
check_breakpoints (CORE_ADDR stop_pc)
{
struct process_info *proc = current_process ();
Index: src/gdb/gdbserver/mem-break.h
===================================================================
--- src.orig/gdb/gdbserver/mem-break.h 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/mem-break.h 2010-06-25 12:01:29.000000000 +0100
@@ -78,6 +78,17 @@ void reinsert_breakpoints_at (CORE_ADDR
void uninsert_breakpoints_at (CORE_ADDR where);
+/* Reinsert all breakpoints of the current process (and change their
+ status to inserted). */
+
+void reinsert_all_breakpoints (void);
+
+/* Uninsert all breakpoints of the current process (and change their
+ status to uninserted). This still leaves the breakpoints in the
+ table. */
+
+void uninsert_all_breakpoints (void);
+
/* See if any breakpoint claims ownership of STOP_PC. Call the handler for
the breakpoint, if found. */
Index: src/gdb/gdbserver/tracepoint.c
===================================================================
--- src.orig/gdb/gdbserver/tracepoint.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/tracepoint.c 2010-06-25 16:37:10.000000000 +0100
@@ -135,6 +135,9 @@ trace_vdebug (const char *fmt, ...)
# define get_raw_reg gdb_agent_get_raw_reg
# define get_trace_state_variable_value gdb_agent_get_trace_state_variable_value
# define set_trace_state_variable_value gdb_agent_set_trace_state_variable_value
+# define ust_loaded gdb_agent_ust_loaded
+# define helper_thread_id gdb_agent_helper_thread_id
+# define cmd_buf gdb_agent_cmd_buf
#endif
#ifndef IN_PROCESS_AGENT
@@ -168,6 +171,9 @@ struct ipa_sym_addresses
CORE_ADDR addr_get_raw_reg;
CORE_ADDR addr_get_trace_state_variable_value;
CORE_ADDR addr_set_trace_state_variable_value;
+ CORE_ADDR addr_ust_loaded;
+ CORE_ADDR addr_helper_thread_id;
+ CORE_ADDR addr_cmd_buf;
};
#define STRINGIZE_1(STR) #STR
@@ -209,6 +215,9 @@ static struct
IPA_SYM(get_raw_reg),
IPA_SYM(get_trace_state_variable_value),
IPA_SYM(set_trace_state_variable_value),
+ IPA_SYM(ust_loaded),
+ IPA_SYM(helper_thread_id),
+ IPA_SYM(cmd_buf),
};
struct ipa_sym_addresses ipa_sym_addrs;
@@ -223,6 +232,29 @@ in_process_agent_loaded (void)
static int read_inferior_integer (CORE_ADDR symaddr, int *val);
+/* Returns true if both the in-process agent library and the static
+ tracepoints libraries are loaded in the inferior. */
+
+static int
+in_process_agent_loaded_ust (void)
+{
+ int loaded = 0;
+
+ if (!in_process_agent_loaded ())
+ {
+ warning ("In-process agent not loaded");
+ return 0;
+ }
+
+ if (read_inferior_integer (ipa_sym_addrs.addr_ust_loaded, &loaded))
+ {
+ warning ("Error reading ust_loaded in lib");
+ return 0;
+ }
+
+ return loaded;
+}
+
static void
write_e_ipa_not_loaded (char *buffer)
{
@@ -231,6 +263,24 @@ write_e_ipa_not_loaded (char *buffer)
"Dynamic tracepoints unavailable.");
}
+/* Write an error to BUFFER indicating that UST isn't loaded in the
+ inferior. */
+
+static void
+write_e_ust_not_loaded (char *buffer)
+{
+#ifdef HAVE_UST
+ sprintf (buffer,
+ "E.UST library not loaded in process. "
+ "Static tracepoints unavailable.");
+#else
+ sprintf (buffer, "E.GDBserver was built without static tracepoints support");
+#endif
+}
+
+/* If the in-process agent library isn't loaded in the inferior, write
+ an error to BUFFER, and return 1. Otherwise, return 0. */
+
static int
maybe_write_ipa_not_loaded (char *buffer)
{
@@ -242,6 +292,26 @@ maybe_write_ipa_not_loaded (char *buffer
return 0;
}
+/* If the in-process agent library and the ust (static tracepoints)
+ library aren't loaded in the inferior, write an error to BUFFER,
+ and return 1. Otherwise, return 0. */
+
+static int
+maybe_write_ipa_ust_not_loaded (char *buffer)
+{
+ if (!in_process_agent_loaded ())
+ {
+ write_e_ipa_not_loaded (buffer);
+ return 1;
+ }
+ else if (!in_process_agent_loaded_ust ())
+ {
+ write_e_ust_not_loaded (buffer);
+ return 1;
+ }
+ return 0;
+}
+
/* Cache all future symbols that the tracepoints module might request.
We can not request symbols at arbitrary states in the remote
protocol, only when the client tells us that new symbols are
@@ -347,6 +417,8 @@ static void download_tracepoints (void);
static void download_trace_state_variables (void);
static void upload_fast_traceframes (void);
+static int run_inferior_command (char *cmd);
+
static int
read_inferior_integer (CORE_ADDR symaddr, int *val)
{
@@ -542,6 +614,12 @@ struct eval_expr_action
struct agent_expr *expr;
};
+/* An 'L' (collect static trace data) action. */
+struct collect_static_trace_data_action
+{
+ struct tracepoint_action base;
+};
+
/* This structure describes a piece of the source-level definition of
the tracepoint. The contents are not interpreted by the target,
but preserved verbatim for uploading upon reconnection. */
@@ -569,6 +647,10 @@ enum tracepoint_type
/* A fast tracepoint implemented with a jump instead of a trap. */
fast_tracepoint,
+
+ /* A static tracepoint, implemented by a program call into a tracing
+ library. */
+ static_tracepoint
};
struct tracepoint_hit_ctx;
@@ -667,8 +749,8 @@ struct tracepoint
char **step_actions_str;
/* Handle returned by the breakpoint or tracepoint module when we
- inserted the trap or jump. NULL if we haven't inserted it
- yet. */
+ inserted the trap or jump, or hooked into a static tracepoint.
+ NULL if we haven't inserted it yet. */
void *handle;
#endif
@@ -1157,6 +1239,35 @@ struct fast_tracepoint_ctx
struct tracepoint *tpoint;
};
+/* Static tracepoint specific data to be passed down to
+ collect_data_at_tracepoint. */
+struct static_tracepoint_ctx
+{
+ struct tracepoint_hit_ctx base;
+
+ /* The regcache corresponding to the registers state at the time of
+ the tracepoint hit. Initialized lazily, from REGS. */
+ struct regcache regcache;
+ int regcache_initted;
+
+ /* The buffer space REGCACHE above uses. We use a separate buffer
+ instead of letting the regcache malloc for both signal safety and
+ performance reasons; this is allocated on the stack instead. */
+ unsigned char *regspace;
+
+ /* The register buffer as passed on by lttng/ust. */
+ struct registers *regs;
+
+ /* The "printf" formatter and the args the user passed to the marker
+ call. We use this to be able to collect "static trace data"
+ ($_sdata). */
+ const char *fmt;
+ va_list *args;
+
+ /* The GDB tracepoint matching the probed marker that was "hit". */
+ struct tracepoint *tpoint;
+};
+
#else
/* Static tracepoint specific data to be passed down to
@@ -1228,6 +1339,10 @@ static struct tracepoint *fast_tracepoin
#define cmpxchg(mem, oldval, newval) \
__sync_val_compare_and_swap (mem, oldval, newval)
+/* The size in bytes of the buffer used to talk to the IPA helper
+ thread. */
+#define CMD_BUF_SIZE 1024
+
/* Record that an error occurred during expression evaluation. */
static void
@@ -1756,6 +1871,18 @@ add_tracepoint_action (struct tracepoint
++act;
break;
}
+ case 'L':
+ {
+ struct collect_static_trace_data_action *raction;
+
+ raction = xmalloc (sizeof *raction);
+ raction->base.type = *act;
+ action = &raction->base;
+
+ trace_debug ("Want to collect static trace data");
+ ++act;
+ break;
+ }
case 'S':
trace_debug ("Unexpected step action, ignoring");
++act;
@@ -2147,6 +2274,17 @@ cmd_qtinit (char *packet)
write_ok (packet);
}
+/* Unprobe the UST marker at ADDRESS. */
+
+static void
+unprobe_marker_at (CORE_ADDR address)
+{
+ char cmd[CMD_BUF_SIZE];
+
+ sprintf (cmd, "unprobe_marker_at:%s", paddress (address));
+ run_inferior_command (cmd);
+}
+
/* Restore the program to its pre-tracing state. This routine may be called
in error situations, so it needs to be careful about only restoring
from known-valid bits. */
@@ -2186,6 +2324,19 @@ clear_installed_tracepoints (void)
case fast_tracepoint:
delete_fast_tracepoint_jump (tpoint->handle);
break;
+ case static_tracepoint:
+ if (prev_stpoint != NULL
+ && prev_stpoint->address == tpoint->address)
+ /* Nothing to do. We already unprobed a tracepoint set at
+ this marker address (and there can only be one probe
+ per marker). */
+ ;
+ else
+ {
+ unprobe_marker_at (tpoint->address);
+ prev_stpoint = tpoint;
+ }
+ break;
}
tpoint->handle = NULL;
@@ -2258,6 +2409,11 @@ cmd_qtdp (char *own_buf)
packet = unpack_varlen_hex (packet, &count);
tpoint->orig_size = count;
}
+ else if (*packet == 'S')
+ {
+ tpoint->type = static_tracepoint;
+ ++packet;
+ }
else if (*packet == 'X')
{
actparm = (char *) packet;
@@ -2570,12 +2726,39 @@ sort_tracepoints (void)
}
}
+/* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
+ the command fails, or 0 otherwise. If the command ran
+ successfully, but probing the marker failed, ERROUT will be filled
+ with the error to reply to GDB, and -1 is also returned. This
+ allows directly passing IPA errors to GDB. */
+
+static int
+probe_marker_at (CORE_ADDR address, char *errout)
+{
+ char cmd[CMD_BUF_SIZE];
+ int err;
+
+ sprintf (cmd, "probe_marker_at:%s", paddress (address));
+ err = run_inferior_command (cmd);
+
+ if (err == 0)
+ {
+ if (*cmd == 'E')
+ {
+ strcpy (errout, cmd);
+ return -1;
+ }
+ }
+
+ return err;
+}
+
#define MAX_JUMP_SIZE 20
static void
cmd_qtstart (char *packet)
{
- struct tracepoint *tpoint, *prev_ftpoint;
+ struct tracepoint *tpoint, *prev_ftpoint, *prev_stpoint;
int slow_tracepoint_count, fast_count;
CORE_ADDR jump_entry;
@@ -2614,6 +2797,9 @@ cmd_qtstart (char *packet)
/* No previous fast tpoint yet. */
prev_ftpoint = NULL;
+ /* No previous static tpoint yet. */
+ prev_stpoint = NULL;
+
*packet = '\0';
/* Install tracepoints. */
@@ -2699,6 +2885,32 @@ cmd_qtstart (char *packet)
}
}
}
+ else if (tpoint->type == static_tracepoint)
+ {
+ if (maybe_write_ipa_ust_not_loaded (packet))
+ {
+ trace_debug ("Requested a static tracepoint, but static "
+ "tracepoints are not supported.");
+ break;
+ }
+
+ /* Can only probe a given marker once. */
+ if (prev_stpoint != NULL && prev_stpoint->address == tpoint->address)
+ {
+ tpoint->handle = (void *) -1;
+ }
+ else
+ {
+ if (probe_marker_at (tpoint->address, packet) == 0)
+ {
+ tpoint->handle = (void *) -1;
+
+ /* So that we can handle multiple static tracepoints
+ at the same address easily. */
+ prev_stpoint = tpoint;
+ }
+ }
+ }
/* Any failure in the inner loop is sufficient cause to give
up. */
@@ -3039,6 +3251,8 @@ response_tracepoint (char *packet, struc
tpoint->pass_count);
if (tpoint->type == fast_tracepoint)
sprintf (packet + strlen (packet), ":F%x", tpoint->orig_size);
+ else if (tpoint->type == static_tracepoint)
+ sprintf (packet + strlen (packet), ":S");
if (tpoint->cond)
{
@@ -3213,6 +3427,36 @@ cmd_qtsv (char *packet)
strcpy (packet, "l");
}
+/* Return the first static tracepoint marker, and initialize the state
+ machine that will iterate through all the static tracepoints
+ markers. */
+
+static void
+cmd_qtfstm (char *packet)
+{
+ if (!maybe_write_ipa_ust_not_loaded (packet))
+ run_inferior_command (packet);
+}
+
+/* Return additional static tracepoints markers. */
+
+static void
+cmd_qtsstm (char *packet)
+{
+ if (!maybe_write_ipa_ust_not_loaded (packet))
+ run_inferior_command (packet);
+}
+
+/* Return the definition of the static tracepoint at a given address.
+ Result packet is the same as qTsST's. */
+
+static void
+cmd_qtstmat (char *packet)
+{
+ if (!maybe_write_ipa_ust_not_loaded (packet))
+ run_inferior_command (packet);
+}
+
/* Respond to qTBuffer packet with a block of raw data from the trace
buffer. GDB may ask for a lot, but we are allowed to reply with
only as much as will fit within packet limits or whatever. */
@@ -3384,6 +3628,21 @@ handle_tracepoint_query (char *packet)
cmd_qtbuffer (packet);
return 1;
}
+ else if (strcmp ("qTfSTM", packet) == 0)
+ {
+ cmd_qtfstm (packet);
+ return 1;
+ }
+ else if (strcmp ("qTsSTM", packet) == 0)
+ {
+ cmd_qtsstm (packet);
+ return 1;
+ }
+ else if (strncmp ("qTSTMat:", packet, strlen ("qTSTMat:")) == 0)
+ {
+ cmd_qtstmat (packet);
+ return 1;
+ }
return 0;
}
@@ -3697,6 +3956,14 @@ tracepoint_was_hit (struct thread_info *
#endif
+#if defined IN_PROCESS_AGENT && defined HAVE_UST
+struct ust_marker_data;
+static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
+ CORE_ADDR stop_pc,
+ struct tracepoint *tpoint,
+ struct traceframe *tframe);
+#endif
+
/* Create a trace frame for the hit of the given tracepoint in the
given thread. */
@@ -3803,6 +4070,25 @@ get_context_regcache (struct tracepoint_
}
regcache = &fctx->regcache;
}
+#ifdef HAVE_UST
+ if (ctx->type == static_tracepoint)
+ {
+ struct static_tracepoint_ctx *sctx = (struct static_tracepoint_ctx *) ctx;
+ if (!sctx->regcache_initted)
+ {
+ sctx->regcache_initted = 1;
+ init_register_cache (&sctx->regcache, sctx->regspace);
+ supply_regblock (&sctx->regcache, NULL);
+ /* Pass down the tracepoint address, because REGS doesn't
+ include the PC, but we know what it must have been. */
+ supply_static_tracepoint_registers (&sctx->regcache,
+ (const unsigned char *)
+ sctx->regs,
+ sctx->tpoint->address);
+ }
+ regcache = &sctx->regcache;
+ }
+#endif
#else
if (ctx->type == trap_tracepoint)
{
@@ -3910,6 +4196,18 @@ do_action_at_tracepoint (struct tracepoi
}
}
break;
+ case 'L':
+ {
+#if defined IN_PROCESS_AGENT && defined HAVE_UST
+ trace_debug ("Want to collect static trace data");
+ collect_ust_data_at_tracepoint (ctx, stop_pc,
+ tpoint, tframe);
+#else
+ trace_debug ("warning: collecting static trace data, "
+ "but static tracepoints are not supported");
+#endif
+ }
+ break;
default:
trace_debug ("unknown trace action '%c', ignoring", taction->type);
break;
@@ -4494,6 +4792,11 @@ traceframe_find_block_type (unsigned cha
/* Skip over the TSV block. */
dataptr += (sizeof (int) + sizeof (LONGEST));
break;
+ case 'S':
+ /* Skip over the static trace data block. */
+ memcpy (&mlen, dataptr, sizeof (mlen));
+ dataptr += (sizeof (mlen) + mlen);
+ break;
default:
trace_debug ("traceframe %d has unknown block type 0x%x",
tfnum, blocktype);
@@ -4684,6 +4987,59 @@ traceframe_read_tsv (int tsvnum, LONGEST
return 1;
}
+/* Read a requested block of static tracepoint data from a trace
+ frame. */
+
+int
+traceframe_read_sdata (int tfnum, ULONGEST offset,
+ unsigned char *buf, ULONGEST length,
+ ULONGEST *nbytes)
+{
+ struct traceframe *tframe;
+ unsigned char *database, *dataptr;
+ unsigned int datasize;
+ unsigned short mlen;
+
+ trace_debug ("traceframe_read_sdata");
+
+ tframe = find_traceframe (tfnum);
+
+ if (!tframe)
+ {
+ trace_debug ("traceframe %d not found", tfnum);
+ return 1;
+ }
+
+ datasize = tframe->data_size;
+ database = &tframe->data[0];
+
+ /* Iterate through a traceframe's blocks, looking for static
+ tracepoint data. */
+ dataptr = traceframe_find_block_type (database, datasize,
+ tfnum, 'S');
+ if (dataptr != NULL)
+ {
+ memcpy (&mlen, dataptr, sizeof (mlen));
+ dataptr += sizeof (mlen);
+ if (offset < mlen)
+ {
+ if (offset + length > mlen)
+ length = mlen - offset;
+
+ memcpy (buf, dataptr, length);
+ *nbytes = length;
+ }
+ else
+ *nbytes = 0;
+ return 0;
+ }
+
+ trace_debug ("traceframe %d has no static trace data", tfnum);
+
+ *nbytes = 0;
+ return 0;
+}
+
/* Return the first fast tracepoint whose jump pad contains PC. */
static struct tracepoint *
@@ -5742,6 +6098,14 @@ download_tracepoints (void)
expr);
break;
}
+ case 'L':
+ ipa_action = target_malloc
+ (sizeof (struct collect_static_trace_data_action));
+ write_inferior_memory
+ (ipa_action,
+ (unsigned char *) action,
+ sizeof (struct collect_static_trace_data_action));
+ break;
default:
trace_debug ("unknown trace action '%c', ignoring",
action->type);
@@ -6087,20 +6451,901 @@ upload_fast_traceframes (void)
#ifdef IN_PROCESS_AGENT
-#include <sys/mman.h>
-#include <fcntl.h>
+IP_AGENT_EXPORT int ust_loaded;
+IP_AGENT_EXPORT char cmd_buf[CMD_BUF_SIZE];
-IP_AGENT_EXPORT char *gdb_tp_heap_buffer;
-IP_AGENT_EXPORT char *gdb_jump_pad_buffer;
-IP_AGENT_EXPORT char *gdb_jump_pad_buffer_end;
+#ifdef HAVE_UST
-static void __attribute__ ((constructor))
-initialize_tracepoint_ftlib (void)
+/* Static tracepoints. */
+
+/* UST puts a "struct tracepoint" in the global namespace, which
+ conflicts with our tracepoint. Arguably, being a library, it
+ shouldn't take ownership of such a generic name. We work around it
+ here. */
+#define tracepoint ust_tracepoint
+#include <ust/ust.h>
+#undef tracepoint
+
+extern int serialize_to_text (char *outbuf, int bufsize,
+ const char *fmt, va_list ap);
+
+#define GDB_PROBE_NAME "gdb"
+
+/* We dynamically search for the UST symbols instead of linking them
+ in. This lets the user decide if the application uses static
+ tracepoints, instead of always pulling libust.so in. This vector
+ holds pointers to all functions we care about. */
+
+static struct
{
- initialize_tracepoint ();
+ int (*serialize_to_text) (char *outbuf, int bufsize,
+ const char *fmt, va_list ap);
+
+ int (*ltt_probe_register) (struct ltt_available_probe *pdata);
+ int (*ltt_probe_unregister) (struct ltt_available_probe *pdata);
+
+ int (*ltt_marker_connect) (const char *channel, const char *mname,
+ const char *pname);
+ int (*ltt_marker_disconnect) (const char *channel, const char *mname,
+ const char *pname);
+
+ void (*marker_iter_start) (struct marker_iter *iter);
+ void (*marker_iter_next) (struct marker_iter *iter);
+ void (*marker_iter_stop) (struct marker_iter *iter);
+ void (*marker_iter_reset) (struct marker_iter *iter);
+} ust_ops;
+
+#include <dlfcn.h>
+
+/* Cast through typeof to catch incompatible API changes. Since UST
+ only builds with gcc, we can freely use gcc extensions here
+ too. */
+#define GET_UST_SYM(SYM) \
+ do \
+ { \
+ if (ust_ops.SYM == NULL) \
+ ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
+ if (ust_ops.SYM == NULL) \
+ return 0; \
+ } while (0)
+
+#define USTF(SYM) ust_ops.SYM
+
+/* Get pointers to all libust.so functions we care about. */
+
+static int
+dlsym_ust (void)
+{
+ GET_UST_SYM (serialize_to_text);
+
+ GET_UST_SYM (ltt_probe_register);
+ GET_UST_SYM (ltt_probe_unregister);
+ GET_UST_SYM (ltt_marker_connect);
+ GET_UST_SYM (ltt_marker_disconnect);
+
+ GET_UST_SYM (marker_iter_start);
+ GET_UST_SYM (marker_iter_next);
+ GET_UST_SYM (marker_iter_stop);
+ GET_UST_SYM (marker_iter_reset);
+
+ ust_loaded = 1;
+ return 1;
}
-#endif
+/* Given an UST marker, return the matching gdb static tracepoint.
+ The match is done by address. */
+
+static struct tracepoint *
+ust_marker_to_static_tracepoint (const struct marker *mdata)
+{
+ struct tracepoint *tpoint;
+
+ for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
+ {
+ if (!tpoint->enabled || tpoint->type != static_tracepoint)
+ continue;
+
+ if (tpoint->address == (uintptr_t) mdata->location)
+ return tpoint;
+ }
+
+ return NULL;
+}
+
+/* The probe function we install on lttng/ust markers. Whenever a
+ probed ust marker is hit, this function is called. This is similar
+ to gdb_collect, only for static tracepoints, instead of fast
+ tracepoints. */
+
+static void
+gdb_probe (const struct marker *mdata, void *probe_private,
+ struct registers *regs, void *call_private,
+ const char *fmt, va_list *args)
+{
+ struct tracepoint *tpoint;
+ struct static_tracepoint_ctx ctx;
+
+ /* Don't do anything until the trace run is completely set up. */
+ if (!tracing)
+ {
+ trace_debug ("gdb_probe: not tracing\n");
+ return;
+ }
+
+ ctx.base.type = static_tracepoint;
+ ctx.regcache_initted = 0;
+ ctx.regs = regs;
+ ctx.fmt = fmt;
+ ctx.args = args;
+
+ /* Wrap the regblock in a register cache (in the stack, we don't
+ want to malloc here). */
+ ctx.regspace = alloca (register_cache_size ());
+ if (ctx.regspace == NULL)
+ {
+ trace_debug ("Trace buffer block allocation failed, skipping");
+ return;
+ }
+
+ tpoint = ust_marker_to_static_tracepoint (mdata);
+ if (tpoint == NULL)
+ {
+ trace_debug ("gdb_probe: marker not known: "
+ "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
+ mdata->location, mdata->channel,
+ mdata->name, mdata->format);
+ return;
+ }
+
+ ctx.tpoint = tpoint;
+
+ trace_debug ("gdb_probe: collecting marker: "
+ "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
+ mdata->location, mdata->channel,
+ mdata->name, mdata->format);
+
+ /* Test the condition if present, and collect if true. */
+ if (tpoint->cond == NULL
+ || condition_true_at_tracepoint ((struct tracepoint_hit_ctx *) &ctx,
+ tpoint))
+ {
+ collect_data_at_tracepoint ((struct tracepoint_hit_ctx *) &ctx,
+ tpoint->address, tpoint);
+
+ if (stopping_tracepoint
+ || trace_buffer_is_full
+ || expr_eval_result != expr_eval_no_error)
+ stop_tracing ();
+ }
+ else
+ {
+ /* If there was a condition and it evaluated to false, the only
+ way we would stop tracing is if there was an error during
+ condition expression evaluation. */
+ if (expr_eval_result != expr_eval_no_error)
+ stop_tracing ();
+ }
+}
+
+/* Called if the gdb static tracepoint requested collecting "$_sdata",
+ static tracepoint string data. This is a string passed to the
+ tracing library by the user, at the time of the tracepoint marker
+ call. E.g., in the UST marker call:
+
+ trace_mark (ust, bar33, "str %s", "FOOBAZ");
+
+ the collected data is "str FOOBAZ".
+*/
+
+static void
+collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
+ CORE_ADDR stop_pc,
+ struct tracepoint *tpoint,
+ struct traceframe *tframe)
+{
+ struct static_tracepoint_ctx *umd = (struct static_tracepoint_ctx *) ctx;
+ unsigned char *bufspace;
+ int size;
+ va_list copy;
+ unsigned short blocklen;
+
+ if (umd == NULL)
+ {
+ trace_debug ("Wanted to collect static trace data, "
+ "but there's no static trace data");
+ return;
+ }
+
+ va_copy (copy, *umd->args);
+ size = USTF(serialize_to_text) (NULL, 0, umd->fmt, copy);
+ va_end (copy);
+
+ trace_debug ("Want to collect ust data");
+
+ /* 'S' + size + string */
+ bufspace = add_traceframe_block (tframe,
+ 1 + sizeof (blocklen) + size + 1);
+ if (bufspace == NULL)
+ {
+ trace_debug ("Trace buffer block allocation failed, skipping");
+ return;
+ }
+
+ /* Identify a static trace data block. */
+ *bufspace = 'S';
+
+ blocklen = size + 1;
+ memcpy (bufspace + 1, &blocklen, sizeof (blocklen));
+
+ va_copy (copy, *umd->args);
+ USTF(serialize_to_text) ((char *) bufspace + 1 + sizeof (blocklen),
+ size + 1, umd->fmt, copy);
+ va_end (copy);
+
+ trace_debug ("Storing static tracepoint data in regblock: %s",
+ bufspace + 1 + sizeof (blocklen));
+}
+
+/* The probe to register with lttng/ust. */
+static struct ltt_available_probe gdb_ust_probe =
+ {
+ GDB_PROBE_NAME,
+ NULL,
+ gdb_probe,
+ };
+
+#endif /* HAVE_UST */
+#endif /* IN_PROCESS_AGENT */
+
+#ifdef HAVE_UST
+
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#ifndef UNIX_PATH_MAX
+#define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
+#endif
+
+/* Where we put the socked used for synchronization. */
+#define SOCK_DIR "/tmp"
+
+#endif /* HAVE_UST */
+
+#ifndef IN_PROCESS_AGENT
+
+#ifdef HAVE_UST
+
+static int
+gdb_ust_connect_sync_socket (int pid)
+{
+ struct sockaddr_un addr;
+ int res, fd;
+ char path[UNIX_PATH_MAX];
+
+ res = snprintf (path, UNIX_PATH_MAX, "%s/gdb_ust%d", SOCK_DIR, pid);
+ if (res >= UNIX_PATH_MAX)
+ {
+ trace_debug ("string overflow allocating socket name");
+ return -1;
+ }
+
+ res = fd = socket (PF_UNIX, SOCK_STREAM, 0);
+ if (res == -1)
+ {
+ warning ("error opening sync socket: %s\n", strerror (errno));
+ return -1;
+ }
+
+ addr.sun_family = AF_UNIX;
+
+ res = snprintf (addr.sun_path, UNIX_PATH_MAX, "%s", path);
+ if (res >= UNIX_PATH_MAX)
+ {
+ warning ("string overflow allocating socket name\n");
+ close (fd);
+ return -1;
+ }
+
+ res = connect (fd, (struct sockaddr *) &addr, sizeof (addr));
+ if (res == -1)
+ {
+ warning ("error connecting sync socket (%s): %s. "
+ "Make sure the directory exists and that it is writable.",
+ path, strerror (errno));
+ close (fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+/* Resume thread PTID. */
+
+static void
+resume_thread (ptid_t ptid)
+{
+ struct thread_resume resume_info;
+
+ resume_info.thread = ptid;
+ resume_info.kind = resume_continue;
+ resume_info.sig = TARGET_SIGNAL_0;
+ (*the_target->resume) (&resume_info, 1);
+}
+
+/* Stop thread PTID. */
+
+static void
+stop_thread (ptid_t ptid)
+{
+ struct thread_resume resume_info;
+
+ resume_info.thread = ptid;
+ resume_info.kind = resume_stop;
+ resume_info.sig = TARGET_SIGNAL_0;
+ (*the_target->resume) (&resume_info, 1);
+}
+
+/* Ask the in-process agent to run a command. Since we don't want to
+ have to handle the IPA hitting breakpoints while running the
+ command, we pause all threads, remove all breakpoints, and then set
+ the helper thread re-running. We communicate with the helper
+ thread by means of direct memory xfering, and a socket for
+ synchronization. */
+
+static int
+run_inferior_command (char *cmd)
+{
+ int err = -1;
+ int fd = -1;
+ int pid = ptid_get_pid (current_inferior->entry.id);
+ int tid;
+ ptid_t ptid = null_ptid;
+
+ trace_debug ("run_inferior_command: running: %s", cmd);
+
+ pause_all (0);
+ uninsert_all_breakpoints ();
+
+ if (read_inferior_integer (ipa_sym_addrs.addr_helper_thread_id, &tid))
+ {
+ warning ("Error reading helper thread's id in lib");
+ goto out;
+ }
+
+ if (tid == 0)
+ {
+ warning ("helper thread not initialized yet");
+ goto out;
+ }
+
+ if (write_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
+ (unsigned char *) cmd, strlen (cmd) + 1))
+ {
+ warning ("Error writing command");
+ goto out;
+ }
+
+ ptid = ptid_build (pid, tid, 0);
+
+ resume_thread (ptid);
+
+ fd = gdb_ust_connect_sync_socket (pid);
+ if (fd >= 0)
+ {
+ char buf[1] = "";
+ int ret;
+
+ trace_debug ("signalling helper thread");
+
+ do
+ {
+ ret = write (fd, buf, 1);
+ } while (ret == -1 && errno == EINTR);
+
+ trace_debug ("waiting for helper thread's response");
+
+ do
+ {
+ ret = read (fd, buf, 1);
+ } while (ret == -1 && errno == EINTR);
+
+ close (fd);
+
+ trace_debug ("helper thread's response received");
+ }
+
+ out:
+
+ /* Need to read response with the inferior stopped. */
+ if (!ptid_equal (ptid, null_ptid))
+ {
+ int was_non_stop = non_stop;
+ struct target_waitstatus status;
+
+ stop_thread (ptid);
+ non_stop = 1;
+ mywait (ptid, &status, 0, 0);
+ non_stop = was_non_stop;
+ }
+
+ if (fd >= 0)
+ {
+ if (read_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
+ (unsigned char *) cmd, CMD_BUF_SIZE))
+ {
+ warning ("Error reading command response");
+ }
+ else
+ {
+ err = 0;
+ trace_debug ("run_inferior_command: response: %s", cmd);
+ }
+ }
+
+ reinsert_all_breakpoints ();
+ unpause_all (0);
+
+ return err;
+}
+
+#else /* HAVE_UST */
+
+static int
+run_inferior_command (char *cmd)
+{
+ return -1;
+}
+
+#endif /* HAVE_UST */
+
+#else /* !IN_PROCESS_AGENT */
+
+/* Thread ID of the helper thread. GDBserver reads this to know which
+ is the help thread. This is an LWP id on Linux. */
+int helper_thread_id;
+
+#ifdef HAVE_UST
+
+static int
+init_named_socket (const char *name)
+{
+ int result, fd;
+ struct sockaddr_un addr;
+
+ result = fd = socket (PF_UNIX, SOCK_STREAM, 0);
+ if (result == -1)
+ {
+ warning ("socket creation failed: %s", strerror (errno));
+ return -1;
+ }
+
+ addr.sun_family = AF_UNIX;
+
+ strncpy (addr.sun_path, name, UNIX_PATH_MAX);
+ addr.sun_path[UNIX_PATH_MAX - 1] = '\0';
+
+ result = access (name, F_OK);
+ if (result == 0)
+ {
+ /* File exists. */
+ result = unlink (name);
+ if (result == -1)
+ {
+ warning ("unlink failed: %s", strerror (errno));
+ close (fd);
+ return -1;
+ }
+ warning ("socket %s already exists; overwriting", name);
+ }
+
+ result = bind (fd, (struct sockaddr *) &addr, sizeof (addr));
+ if (result == -1)
+ {
+ warning ("bind failed: %s", strerror (errno));
+ close (fd);
+ return -1;
+ }
+
+ result = listen (fd, 1);
+ if (result == -1)
+ {
+ warning ("listen: %s", strerror (errno));
+ close (fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+static int
+gdb_ust_socket_init (void)
+{
+ int result, fd;
+ char name[UNIX_PATH_MAX];
+
+ result = snprintf (name, UNIX_PATH_MAX, "%s/gdb_ust%d",
+ SOCK_DIR, getpid ());
+ if (result >= UNIX_PATH_MAX)
+ {
+ trace_debug ("string overflow allocating socket name");
+ return -1;
+ }
+
+ fd = init_named_socket (name);
+ if (fd < 0)
+ warning ("Error initializing named socket (%s) for communication with the "
+ "ust helper thread. Check that directory exists and that it "
+ "is writable.", name);
+
+ return fd;
+}
+
+/* Return an hexstr version of the STR C string, fit for sending to
+ GDB. */
+
+static char *
+cstr_to_hexstr (const char *str)
+{
+ int len = strlen (str);
+ char *hexstr = xmalloc (len * 2 + 1);
+ convert_int_to_ascii ((gdb_byte *) str, hexstr, len);
+ return hexstr;
+}
+
+/* The next marker to be returned on a qTsST command. */
+static const struct marker *next_st;
+
+/* Returns the first known marker. */
+
+struct marker *
+first_marker (void)
+{
+ struct marker_iter iter;
+
+ USTF(marker_iter_reset) (&iter);
+ USTF(marker_iter_start) (&iter);
+
+ return iter.marker;
+}
+
+/* Returns the marker following M. */
+
+const struct marker *
+next_marker (const struct marker *m)
+{
+ struct marker_iter iter;
+
+ USTF(marker_iter_reset) (&iter);
+ USTF(marker_iter_start) (&iter);
+
+ for (; iter.marker != NULL; USTF(marker_iter_next) (&iter))
+ {
+ if (iter.marker == m)
+ {
+ USTF(marker_iter_next) (&iter);
+ return iter.marker;
+ }
+ }
+
+ return NULL;
+}
+
+/* Compose packet that is the response to the qTsSTM/qTfSTM/qTST;at
+ packets. */
+
+static void
+response_ust_marker (char *packet, const struct marker *st)
+{
+ char *strid, *format, *tmp;
+
+ next_st = next_marker (st);
+
+ tmp = xmalloc (strlen (st->channel) + 1 +
+ strlen (st->name) + 1);
+ sprintf (tmp, "%s/%s", st->channel, st->name);
+
+ strid = cstr_to_hexstr (tmp);
+ free (tmp);
+
+ format = cstr_to_hexstr (st->format);
+
+ sprintf (packet, "m%s:%s:%s",
+ paddress ((uintptr_t) st->location),
+ strid,
+ format);
+
+ free (strid);
+ free (format);
+}
+
+/* Return the first static tracepoint, and initialize the state
+ machine that will iterate through all the static tracepoints. */
+
+static void
+cmd_qtfstm (char *packet)
+{
+ trace_debug ("Returning first trace state variable definition");
+
+ if (first_marker ())
+ response_ust_marker (packet, first_marker ());
+ else
+ strcpy (packet, "l");
+}
+
+/* Return additional trace state variable definitions. */
+
+static void
+cmd_qtsstm (char *packet)
+{
+ trace_debug ("Returning static tracepoint");
+
+ if (next_st)
+ response_ust_marker (packet, next_st);
+ else
+ strcpy (packet, "l");
+}
+
+/* Disconnect the GDB probe from a marker at a given address. */
+
+static void
+unprobe_marker_at (char *packet)
+{
+ char *p = packet;
+ ULONGEST address;
+ struct marker_iter iter;
+
+ p += sizeof ("unprobe_marker_at:") - 1;
+
+ p = unpack_varlen_hex (p, &address);
+
+ USTF(marker_iter_reset) (&iter);
+ USTF(marker_iter_start) (&iter);
+ for (; iter.marker != NULL; USTF(marker_iter_next) (&iter))
+ if ((uintptr_t ) iter.marker->location == address)
+ {
+ int result;
+
+ result = USTF(ltt_marker_disconnect) (iter.marker->channel,
+ iter.marker->name,
+ GDB_PROBE_NAME);
+ if (result < 0)
+ warning ("could not disable marker %s/%s",
+ iter.marker->channel, iter.marker->name);
+ break;
+ }
+}
+
+/* Connect the GDB probe to a marker at a given address. */
+
+static int
+probe_marker_at (char *packet)
+{
+ char *p = packet;
+ ULONGEST address;
+ struct marker_iter iter;
+ struct marker *m;
+
+ p += sizeof ("probe_marker_at:") - 1;
+
+ p = unpack_varlen_hex (p, &address);
+
+ USTF(marker_iter_reset) (&iter);
+
+ for (USTF(marker_iter_start) (&iter), m = iter.marker;
+ m != NULL;
+ USTF(marker_iter_next) (&iter), m = iter.marker)
+ if ((uintptr_t ) m->location == address)
+ {
+ int result;
+
+ trace_debug ("found marker for address. "
+ "ltt_marker_connect (marker = %s/%s)",
+ m->channel, m->name);
+
+ result = USTF(ltt_marker_connect) (m->channel, m->name, GDB_PROBE_NAME);
+ if (result && result != -EEXIST)
+ trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
+ m->channel, m->name, -result);
+
+ if (result < 0)
+ {
+ sprintf (packet, "E.could not connect marker: channel=%s, name=%s",
+ m->channel, m->name);
+ return -1;
+ }
+
+ strcpy (packet, "OK");
+ return 0;
+ }
+
+ sprintf (packet, "E.no marker found at 0x%s", paddress (address));
+ return -1;
+}
+
+static int
+cmd_qtstmat (char *packet)
+{
+ char *p = packet;
+ ULONGEST address;
+ struct marker_iter iter;
+ struct marker *m;
+
+ p += sizeof ("qTSTMat:") - 1;
+
+ p = unpack_varlen_hex (p, &address);
+
+ USTF(marker_iter_reset) (&iter);
+
+ for (USTF(marker_iter_start) (&iter), m = iter.marker;
+ m != NULL;
+ USTF(marker_iter_next) (&iter), m = iter.marker)
+ if ((uintptr_t ) m->location == address)
+ {
+ response_ust_marker (packet, m);
+ return 0;
+ }
+
+ strcpy (packet, "l");
+ return -1;
+}
+
+static void *
+gdb_ust_thread (void *arg)
+{
+ int listen_fd;
+
+ while (1)
+ {
+ listen_fd = gdb_ust_socket_init ();
+
+#ifdef SYS_gettid
+ if (helper_thread_id == 0)
+ helper_thread_id = syscall (SYS_gettid);
+#endif
+
+ if (listen_fd == -1)
+ {
+ warning ("could not create sync socket\n");
+ break;
+ }
+
+ while (1)
+ {
+ socklen_t tmp;
+ struct sockaddr_un sockaddr;
+ int fd;
+ char buf[1];
+ int ret;
+
+ tmp = sizeof (sockaddr);
+
+ do
+ {
+ fd = accept (listen_fd, &sockaddr, &tmp);
+ }
+ /* It seems an ERESTARTSYS can escape out of accept. */
+ while (fd == -512 || (fd == -1 && errno == EINTR));
+
+ if (fd < 0)
+ {
+ warning ("Accept returned %d, error: %s\n",
+ fd, strerror (errno));
+ break;
+ }
+
+ do
+ {
+ ret = read (fd, buf, 1);
+ } while (ret == -1 && errno == EINTR);
+
+ if (ret == -1)
+ {
+ warning ("reading socket (fd=%d) failed with %s",
+ fd, strerror (errno));
+ close (fd);
+ break;
+ }
+
+ if (cmd_buf[0])
+ {
+ if (strcmp ("qTfSTM", cmd_buf) == 0)
+ {
+ cmd_qtfstm (cmd_buf);
+ }
+ else if (strcmp ("qTsSTM", cmd_buf) == 0)
+ {
+ cmd_qtsstm (cmd_buf);
+ }
+ else if (strncmp ("unprobe_marker_at:",
+ cmd_buf,
+ sizeof ("unprobe_marker_at:") - 1) == 0)
+ {
+ unprobe_marker_at (cmd_buf);
+ }
+ else if (strncmp ("probe_marker_at:",
+ cmd_buf,
+ sizeof ("probe_marker_at:") - 1) == 0)
+ {
+ probe_marker_at (cmd_buf);
+ }
+ else if (strncmp ("qTSTMat:",
+ cmd_buf,
+ sizeof ("qTSTMat:") - 1) == 0)
+ {
+ cmd_qtstmat (cmd_buf);
+ }
+ else if (strcmp (cmd_buf, "help") == 0)
+ {
+ strcpy (cmd_buf, "for help, press F1\n");
+ }
+ else
+ strcpy (cmd_buf, "");
+ }
+
+ write (fd, buf, 1);
+ close (fd);
+ }
+ }
+
+ return NULL;
+}
+
+#include <signal.h>
+
+static void
+gdb_ust_init (void)
+{
+ int res;
+ pthread_t thread;
+ sigset_t new_mask;
+ sigset_t orig_mask;
+
+ if (!dlsym_ust ())
+ return;
+
+ /* We want the helper thread to be as transparent as possible, so
+ have it inherit an all-signals-blocked mask. */
+
+ sigfillset (&new_mask);
+ res = pthread_sigmask (SIG_SETMASK, &new_mask, &orig_mask);
+ if (res)
+ fatal ("pthread_sigmask (1) failed: %s", strerror (res));
+
+ res = pthread_create (&thread,
+ NULL,
+ gdb_ust_thread,
+ NULL);
+
+ res = pthread_sigmask (SIG_SETMASK, &orig_mask, NULL);
+ if (res)
+ fatal ("pthread_sigmask (2) failed: %s", strerror (res));
+
+ while (helper_thread_id == 0)
+ usleep (1);
+
+ USTF(ltt_probe_register) (&gdb_ust_probe);
+}
+
+#endif /* HAVE_UST */
+
+#include <sys/mman.h>
+#include <fcntl.h>
+
+IP_AGENT_EXPORT char *gdb_tp_heap_buffer;
+IP_AGENT_EXPORT char *gdb_jump_pad_buffer;
+IP_AGENT_EXPORT char *gdb_jump_pad_buffer_end;
+
+static void __attribute__ ((constructor))
+initialize_tracepoint_ftlib (void)
+{
+ initialize_tracepoint ();
+
+#ifdef HAVE_UST
+ gdb_ust_init ();
+#endif
+}
+
+#endif /* IN_PROCESS_AGENT */
static LONGEST
tsv_get_timestamp (void)
Index: src/gdb/breakpoint.c
===================================================================
--- src.orig/gdb/breakpoint.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/breakpoint.c 2010-06-25 15:58:12.000000000 +0100
@@ -837,7 +837,9 @@ check_no_tracepoint_commands (struct com
int
is_tracepoint (const struct breakpoint *b)
{
- return (b->type == bp_tracepoint || b->type == bp_fast_tracepoint);
+ return (b->type == bp_tracepoint
+ || b->type == bp_fast_tracepoint
+ || b->type == bp_static_tracepoint);
}
/* A helper function that validsates that COMMANDS are valid for a
@@ -861,7 +863,11 @@ validate_commands_for_breakpoint (struct
if (c->control_type == while_stepping_control)
{
if (b->type == bp_fast_tracepoint)
- error (_("The 'while-stepping' command cannot be used for fast tracepoint"));
+ error (_("\
+The 'while-stepping' command cannot be used for fast tracepoint"));
+ else if (b->type == bp_static_tracepoint)
+ error (_("\
+The 'while-stepping' command cannot be used for static tracepoint"));
if (while_stepping)
error (_("The 'while-stepping' command can be used only once"));
@@ -888,6 +894,27 @@ validate_commands_for_breakpoint (struct
}
}
+/* Return a vector of all the static tracepoints set at ADDR. The
+ caller is responsible for releasing the vector. */
+
+VEC(breakpoint_p) *
+static_tracepoints_here (CORE_ADDR addr)
+{
+ struct breakpoint *b;
+ VEC(breakpoint_p) *found = 0;
+ struct bp_location *loc;
+
+ ALL_BREAKPOINTS (b)
+ if (b->type == bp_static_tracepoint)
+ {
+ for (loc = b->loc; loc; loc = loc->next)
+ if (loc->address == addr)
+ VEC_safe_push(breakpoint_p, found, b);
+ }
+
+ return found;
+}
+
/* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
validate that only allowed commands are included.
*/
@@ -4420,6 +4447,7 @@ bpstat_what (bpstat bs)
break;
case bp_tracepoint:
case bp_fast_tracepoint:
+ case bp_static_tracepoint:
/* Tracepoint hits should not be reported back to GDB, and
if one got through somehow, it should have been filtered
out already. */
@@ -4553,6 +4581,7 @@ print_one_breakpoint_location (struct br
{bp_catchpoint, "catchpoint"},
{bp_tracepoint, "tracepoint"},
{bp_fast_tracepoint, "fast tracepoint"},
+ {bp_static_tracepoint, "static tracepoint"},
{bp_jit_event, "jit events"},
};
@@ -4685,6 +4714,7 @@ print_one_breakpoint_location (struct br
case bp_std_terminate_master:
case bp_tracepoint:
case bp_fast_tracepoint:
+ case bp_static_tracepoint:
case bp_jit_event:
if (opts.addressprint)
{
@@ -4755,6 +4785,16 @@ print_one_breakpoint_location (struct br
ui_out_text (uiout, "\n");
+ if (!part_of_multiple && b->static_trace_id)
+ {
+ gdb_assert (b->type == bp_static_tracepoint);
+
+ ui_out_text (uiout, "\tstatic tracepoint id is ");
+ ui_out_field_string (uiout, "static-tracepoint-strid",
+ b->static_trace_id);
+ ui_out_text (uiout, "\n");
+ }
+
if (part_of_multiple && frame_id_p (b->frame_id))
{
annotate_field (6);
@@ -5411,6 +5451,7 @@ allocate_bp_location (struct breakpoint
case bp_catchpoint:
case bp_tracepoint:
case bp_fast_tracepoint:
+ case bp_static_tracepoint:
loc->loc_type = bp_loc_other;
break;
default:
@@ -6787,6 +6828,16 @@ mention (struct breakpoint *b)
printf_filtered (_(" %d"), b->number);
say_where = 1;
break;
+ case bp_static_tracepoint:
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ say_where = 0;
+ break;
+ }
+ printf_filtered (_("Static tracepoint"));
+ printf_filtered (_(" %d"), b->number);
+ say_where = 1;
+ break;
case bp_until:
case bp_finish:
@@ -6966,9 +7017,25 @@ create_breakpoint_sal (struct gdbarch *g
b->ignore_count = ignore_count;
b->enable_state = enabled ? bp_enabled : bp_disabled;
b->disposition = disposition;
-
b->pspace = sals.sals[0].pspace;
+ if (type == bp_static_tracepoint)
+ {
+ struct static_tracepoint_marker marker;
+
+ if (target_static_tracepoint_marker_at (sal.pc, &marker))
+ {
+ b->static_trace_id = xstrdup (marker.str_id);
+ release_static_tracepoint_marker (&marker);
+
+ printf_filtered (_("Probed static tracepoint marker \"%s\"\n"),
+ b->static_trace_id);
+ }
+ else
+ warning (_("\
+Couldn't determine the static tracepoint marker to probe"));
+ }
+
if (enabled && b->pspace->executing_startup
&& (b->type == bp_breakpoint
|| b->type == bp_hardware_breakpoint))
@@ -7381,6 +7448,49 @@ find_condition_and_thread (char *tok, CO
}
}
+/* Decode a static tracepoint marker spec. */
+
+static struct symtabs_and_lines
+decode_static_tracepoint_spec (char **arg_p)
+{
+ struct static_tracepoint_marker stmarker;
+ struct symtabs_and_lines sals;
+ struct symtab_and_line sal;
+ struct symbol *sym;
+ struct cleanup *old_chain;
+ char *p = &(*arg_p)[3];
+ char *endp;
+ char *marker;
+
+ while (*p == ' ' || *p == '\t')
+ p++;
+
+ endp = p;
+ while (*endp != ' ' && *endp != '\t' && *endp != '\0')
+ endp++;
+
+ marker = savestring (p, endp - p);
+ old_chain = make_cleanup (xfree, marker);
+
+ if (!target_static_tracepoint_marker_by_strid (marker, &stmarker))
+ error (_("No known static tracepoint marker named %s"), p);
+
+ init_sal (&sal); /* initialize to zeroes */
+
+ sal.pc = stmarker.address;
+ sal = find_pc_line (stmarker.address, 0);
+
+ sals.nelts = 1;
+ sals.sals = xmalloc (sizeof *sals.sals);
+ sals.sals[0] = sal;
+
+ release_static_tracepoint_marker (&stmarker);
+ do_cleanups (old_chain);
+
+ *arg_p = endp;
+ return sals;
+}
+
/* Set a breakpoint. This function is shared between CLI and MI
functions for setting a breakpoint. This function has two major
modes of operations, selected by the PARSE_CONDITION_AND_THREAD
@@ -7394,7 +7504,7 @@ int
create_breakpoint (struct gdbarch *gdbarch,
char *arg, char *cond_string, int thread,
int parse_condition_and_thread,
- int tempflag, int hardwareflag, int traceflag,
+ int tempflag, enum bptype type_wanted,
int ignore_count,
enum auto_boolean pending_break_support,
struct breakpoint_ops *ops,
@@ -7413,7 +7523,6 @@ create_breakpoint (struct gdbarch *gdbar
int i;
int pending = 0;
int not_found = 0;
- enum bptype type_wanted;
int task = 0;
int prev_bkpt_count = breakpoint_count;
@@ -7426,6 +7535,18 @@ create_breakpoint (struct gdbarch *gdbar
parse_args.addr_string_p = &addr_string;
parse_args.not_found_ptr = ¬_found;
+ if (type_wanted == bp_static_tracepoint
+ && (strncmp (arg, "-m", 2) == 0
+ && (arg[2] == ' ' || arg[2] == '\t')))
+ {
+ sals = decode_static_tracepoint_spec (&arg);
+
+ copy_arg = savestring (addr_start, arg - addr_start);
+ addr_string = xmalloc (sizeof (char **));
+ addr_string[0] = copy_arg;
+ goto done;
+ }
+
e = catch_exception (uiout, do_captured_parse_breakpoint,
&parse_args, RETURN_MASK_ALL);
@@ -7472,6 +7593,8 @@ create_breakpoint (struct gdbarch *gdbar
return 0;
}
+ done:
+
/* Create a chain of things that always need to be cleaned up. */
old_chain = make_cleanup (null_cleanup, 0);
@@ -7503,10 +7626,6 @@ create_breakpoint (struct gdbarch *gdbar
if (!pending)
breakpoint_sals_to_pc (&sals, addr_start);
- type_wanted = (traceflag
- ? (hardwareflag ? bp_fast_tracepoint : bp_tracepoint)
- : (hardwareflag ? bp_hardware_breakpoint : bp_breakpoint));
-
/* Fast tracepoints may have additional restrictions on location. */
if (type_wanted == bp_fast_tracepoint)
check_fast_tracepoint_sals (gdbarch, &sals);
@@ -7599,13 +7718,15 @@ create_breakpoint (struct gdbarch *gdbar
static void
break_command_1 (char *arg, int flag, int from_tty)
{
- int hardwareflag = flag & BP_HARDWAREFLAG;
int tempflag = flag & BP_TEMPFLAG;
+ enum bptype type_wanted = (flag & BP_HARDWAREFLAG
+ ? bp_hardware_breakpoint
+ : bp_breakpoint);
create_breakpoint (get_current_arch (),
arg,
NULL, 0, 1 /* parse arg */,
- tempflag, hardwareflag, 0 /* traceflag */,
+ tempflag, type_wanted,
0 /* Ignore count */,
pending_break_support,
NULL /* breakpoint_ops */,
@@ -8578,7 +8699,7 @@ handle_gnu_v3_exceptions (int tempflag,
create_breakpoint (get_current_arch (),
trigger_func_name, cond_string, -1,
0 /* condition and thread are valid. */,
- tempflag, 0, 0,
+ tempflag, bp_breakpoint,
0,
AUTO_BOOLEAN_TRUE /* pending */,
&gnu_v3_exception_catchpoint_ops, from_tty,
@@ -9630,6 +9751,119 @@ ambiguous_names_p (struct bp_location *l
return 0;
}
+/* When symbols change, it probably means the sources changed as well,
+ and it might mean the static tracepoint markers are no longer at
+ the same address or line numbers they used to be at last we
+ checked. Losing your static tracepoints whenever you rebuild is
+ undesirable. This function tries to resync/rematch gdb static
+ tracepoints with the markers on the target. The heuristic is:
+
+ 1) look for a marker at the old PC. If one is found there, assume
+ to be the same marker. If the name / string id of the marker found
+ is different from the previous known name, assume that means the
+ user renamed the marker in the sources, and output a warning.
+
+ 2) If a marker is no longer found at the same address, it may mean
+ the marker no longer exists. But it may also just mean the code
+ changed a bit. Maybe the user added a few lines of code that made
+ the marker move up or down (in line number terms). Ask the target
+ for info about the marker with the string id as we knew it. If
+ found, update line number and address in the matching static
+ tracepoint. */
+
+static struct symtab_and_line
+update_static_tracepoint (struct breakpoint *b,
+ struct symtab_and_line sal)
+{
+ struct static_tracepoint_marker marker;
+ int i;
+
+ CORE_ADDR pc;
+
+ pc = sal.pc;
+ if (sal.line)
+ find_line_pc (sal.symtab, sal.line, &pc);
+
+ if (target_static_tracepoint_marker_at (pc, &marker))
+ {
+ if (strcmp (b->static_trace_id, marker.str_id) != 0)
+ warning ("\
+static tracepoint %d changed probed target static tracepoint from %s to %s",
+ b->number,
+ b->static_trace_id, marker.str_id);
+
+ xfree (b->static_trace_id);
+ b->static_trace_id = xstrdup (marker.str_id);
+ release_static_tracepoint_marker (&marker);
+
+ return sal;
+ }
+
+ /* Old marker wasn't found on target at lineno. Try looking it up
+ by string ID. */
+ if (!sal.explicit_pc
+ && sal.line != 0
+ && sal.symtab != NULL
+ && b->static_trace_id != NULL
+ && target_static_tracepoint_marker_by_strid (b->static_trace_id,
+ &marker))
+ {
+ struct symtab_and_line sal;
+ struct symbol *sym;
+
+ xfree (b->static_trace_id);
+ b->static_trace_id = xstrdup (marker.str_id);
+
+ warning ("static tracepoint %d (%s) not found at previous line number",
+ b->number, b->static_trace_id);
+
+ init_sal (&sal); /* initialize to zeroes */
+
+ sal.pc = marker.address;
+
+ sal = find_pc_line (marker.address, 0);
+ sym = find_pc_sect_function (marker.address, NULL);
+ ui_out_text (uiout, "Now in ");
+ if (sym)
+ {
+ ui_out_field_string (uiout, "func",
+ SYMBOL_PRINT_NAME (sym));
+ ui_out_text (uiout, " at ");
+ }
+ ui_out_field_string (uiout, "file", sal.symtab->filename);
+ ui_out_text (uiout, ":");
+
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ char *fullname = symtab_to_fullname (sal.symtab);
+
+ if (fullname)
+ ui_out_field_string (uiout, "fullname", fullname);
+ }
+
+ ui_out_field_int (uiout, "line", sal.line);
+ ui_out_text (uiout, "\n");
+
+ b->line_number = sal.line;
+
+ xfree (b->source_file);
+ if (sym)
+ b->source_file = xstrdup (sal.symtab->filename);
+ else
+ b->source_file = NULL;
+
+ xfree (b->addr_string);
+ b->addr_string = xstrprintf ("%s:%d",
+ sal.symtab->filename, b->line_number);
+
+ /* Might be nice to check if function changed, and warn if
+ so. */
+
+ release_static_tracepoint_marker (&marker);
+ }
+ return sal;
+}
+
static void
update_breakpoint_locations (struct breakpoint *b,
struct symtabs_and_lines sals)
@@ -9760,6 +9994,7 @@ breakpoint_re_set_one (void *bint)
case bp_hardware_breakpoint:
case bp_tracepoint:
case bp_fast_tracepoint:
+ case bp_static_tracepoint:
/* Do not attempt to re-set breakpoints disabled during startup. */
if (b->enable_state == bp_startup_disabled)
return 0;
@@ -9780,8 +10015,13 @@ breakpoint_re_set_one (void *bint)
TRY_CATCH (e, RETURN_MASK_ERROR)
{
- sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
- not_found_ptr);
+ if (b->type == bp_static_tracepoint
+ && (strncmp (s, "-m", 2) == 0
+ && (s[2] == ' ' || s[2] == '\t')))
+ sals = decode_static_tracepoint_spec (&s);
+ else
+ sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
+ not_found_ptr);
}
if (e.reason < 0)
{
@@ -9831,6 +10071,9 @@ breakpoint_re_set_one (void *bint)
b->condition_not_parsed = 0;
}
+ if (b->type == bp_static_tracepoint)
+ sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
+
expanded = expand_line_sal_maybe (sals.sals[0]);
}
@@ -10183,6 +10426,7 @@ disable_command (char *args, int from_tt
case bp_breakpoint:
case bp_tracepoint:
case bp_fast_tracepoint:
+ case bp_static_tracepoint:
case bp_catchpoint:
case bp_hardware_breakpoint:
case bp_watchpoint:
@@ -10283,6 +10527,7 @@ enable_command (char *args, int from_tty
case bp_breakpoint:
case bp_tracepoint:
case bp_fast_tracepoint:
+ case bp_static_tracepoint:
case bp_catchpoint:
case bp_hardware_breakpoint:
case bp_watchpoint:
@@ -10583,8 +10828,8 @@ trace_command (char *arg, int from_tty)
if (create_breakpoint (get_current_arch (),
arg,
NULL, 0, 1 /* parse arg */,
- 0 /* tempflag */, 0 /* hardwareflag */,
- 1 /* traceflag */,
+ 0 /* tempflag */,
+ bp_tracepoint /* type_wanted */,
0 /* Ignore count */,
pending_break_support,
NULL,
@@ -10599,8 +10844,26 @@ ftrace_command (char *arg, int from_tty)
if (create_breakpoint (get_current_arch (),
arg,
NULL, 0, 1 /* parse arg */,
- 0 /* tempflag */, 1 /* hardwareflag */,
- 1 /* traceflag */,
+ 0 /* tempflag */,
+ bp_fast_tracepoint /* type_wanted */,
+ 0 /* Ignore count */,
+ pending_break_support,
+ NULL,
+ from_tty,
+ 1 /* enabled */))
+ set_tracepoint_count (breakpoint_count);
+}
+
+/* strace command implementation. Creates a static tracepoint. */
+
+void
+strace_command (char *arg, int from_tty)
+{
+ if (create_breakpoint (get_current_arch (),
+ arg,
+ NULL, 0, 1 /* parse arg */,
+ 0 /* tempflag */,
+ bp_static_tracepoint /* type_wanted */,
0 /* Ignore count */,
pending_break_support,
NULL,
@@ -10662,8 +10925,7 @@ create_tracepoint_from_upload (struct up
addr_str,
utp->cond_string, -1, 0 /* parse cond/thread */,
0 /* tempflag */,
- (utp->type == bp_fast_tracepoint) /* hardwareflag */,
- 1 /* traceflag */,
+ utp->type /* type_wanted */,
0 /* Ignore count */,
pending_break_support,
NULL,
@@ -10985,6 +11247,8 @@ save_breakpoints (char *filename, int fr
{
if (tp->type == bp_fast_tracepoint)
fprintf_unfiltered (fp, "ftrace");
+ if (tp->type == bp_static_tracepoint)
+ fprintf_unfiltered (fp, "strace");
else if (tp->type == bp_tracepoint)
fprintf_unfiltered (fp, "trace");
else if (tp->type == bp_breakpoint && tp->disposition == disp_del)
@@ -11569,6 +11833,31 @@ BREAK_ARGS_HELP ("ftrace") "\n\
Do \"help tracepoints\" for info on other tracepoint commands."));
set_cmd_completer (c, location_completer);
+ c = add_com ("strace", class_breakpoint, strace_command, _("\
+Set a static tracepoint at specified line, function or marker.\n\
+\n\
+strace [LOCATION] [if CONDITION]\n\
+LOCATION may be a line number, function name, \"*\" and an address,\n\
+or -m MARKER_ID.\n\
+If a line number is specified, probe the marker at start of code \n\
+for that line. If a function is specified, probe the marker at start \n\
+of code for that function. If an address is specified, probe the marker\n\
+at that exact address. If a marker id is specified, probe the marker\n\
+with that name. With no LOCATION, uses current execution address of \n\
+selected stack frame.\n\
+Static tracepoints accept an extra collect action --- ``collect $_sdata''.\n\
+This collects arbitrary user data passed in the probe point call to the\n\
+tracing library. You can inspect it when analysing the trace buffer, \n\
+by printing the $_sdata variable like any other convenience variable.\n\
+\n\
+CONDITION is a boolean expression.\n\
+\n\
+Multiple tracepoints at one place are permitted, and useful if conditional.\n\
+\n\
+Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
+Do \"help tracepoints\" for info on other tracepoint commands."));
+ set_cmd_completer (c, location_completer);
+
add_info ("tracepoints", tracepoints_info, _("\
Status of tracepoints, or tracepoint number NUMBER.\n\
Convenience variable \"$tpnum\" contains the number of the\n\
Index: src/gdb/breakpoint.h
===================================================================
--- src.orig/gdb/breakpoint.h 2010-06-25 12:01:15.000000000 +0100
+++ src/gdb/breakpoint.h 2010-06-25 12:01:29.000000000 +0100
@@ -129,6 +129,7 @@ enum bptype
bp_tracepoint,
bp_fast_tracepoint,
+ bp_static_tracepoint,
/* Event for JIT compiled code generation or deletion. */
bp_jit_event,
@@ -536,6 +537,9 @@ struct breakpoint
/* The number of the tracepoint on the target. */
int number_on_target;
+
+ /* The static tracepoint string id, if known. */
+ char *static_trace_id;
};
typedef struct breakpoint *breakpoint_p;
@@ -780,6 +784,8 @@ extern void breakpoint_re_set (void);
extern void breakpoint_re_set_thread (struct breakpoint *);
+extern struct breakpoint *breakpoints_here_p (CORE_ADDR);
+
extern struct breakpoint *set_momentary_breakpoint
(struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
@@ -818,7 +824,7 @@ extern void tbreak_command (char *, int)
extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
char *cond_string, int thread,
int parse_condition_and_thread,
- int tempflag, int hardwareflag, int traceflag,
+ int tempflag, enum bptype wanted_type,
int ignore_count,
enum auto_boolean pending_break_support,
struct breakpoint_ops *ops,
@@ -1040,6 +1046,11 @@ extern VEC(breakpoint_p) *all_tracepoint
extern int is_tracepoint (const struct breakpoint *b);
+/* Return a vector of all static tracepoints defined at ADDR. The
+ vector is newly allocated; the caller should free when done with
+ it. */
+extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr);
+
/* Function that can be passed to read_command_line to validate
that each command is suitable for tracepoint command list. */
extern void check_tracepoint_command (char *line, void *closure);
Index: src/gdb/gdbserver/config.in
===================================================================
--- src.orig/gdb/gdbserver/config.in 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/config.in 2010-06-25 12:01:29.000000000 +0100
@@ -154,6 +154,9 @@
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
+/* Define if UST is available */
+#undef HAVE_UST
+
/* Checking if errno must be defined */
#undef MUST_DEFINE_ERRNO
Index: src/gdb/gdbserver/configure
===================================================================
--- src.orig/gdb/gdbserver/configure 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/configure 2010-06-25 12:01:29.000000000 +0100
@@ -601,6 +601,8 @@ RDYNAMIC
REPORT_BUGS_TEXI
REPORT_BUGS_TO
PKGVERSION
+ustinc
+ustlibs
LIBOBJS
INSTALL_DATA
INSTALL_SCRIPT
@@ -668,6 +670,9 @@ SHELL'
ac_subst_files=''
ac_user_opts='
enable_option_checking
+with_ust
+with_ust_include
+with_ust_lib
with_pkgversion
with_bugurl
with_libthread_db
@@ -1298,6 +1303,11 @@ if test -n "$ac_init_help"; then
Optional Packages:
--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
+ --with-ust=PATH Specify prefix directory for the installed UST package
+ Equivalent to --with-ust-include=PATH/include
+ plus --with-ust-lib=PATH/lib
+ --with-ust-include=PATH Specify directory for installed UST include files
+ --with-ust-lib=PATH Specify the directory for the installed UST library
--with-pkgversion=PKG Use PKG in the version string in place of "GDB"
--with-bugurl=URL Direct users to URL to report a bug
--with-libthread-db=PATH
@@ -1747,8 +1757,10 @@ $as_echo "$ac_res" >&6; }
ac_fn_c_check_decl ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $2 is declared" >&5
-$as_echo_n "checking whether $2 is declared... " >&6; }
+ as_decl_name=`echo $2|sed 's/ *(.*//'`
+ as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
+$as_echo_n "checking whether $as_decl_name is declared... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
@@ -1758,8 +1770,12 @@ $4
int
main ()
{
-#ifndef $2
- (void) $2;
+#ifndef $as_decl_name
+#ifdef __cplusplus
+ (void) $as_decl_use;
+#else
+ (void) $as_decl_name;
+#endif
#endif
;
@@ -3818,6 +3834,86 @@ done
+# Check for UST
+ustlibs=""
+ustinc=""
+
+
+# Check whether --with-ust was given.
+if test "${with_ust+set}" = set; then :
+ withval=$with_ust;
+fi
+
+
+# Check whether --with-ust_include was given.
+if test "${with_ust_include+set}" = set; then :
+ withval=$with_ust_include;
+fi
+
+
+# Check whether --with-ust_lib was given.
+if test "${with_ust_lib+set}" = set; then :
+ withval=$with_ust_lib;
+fi
+
+
+case $with_ust in
+ no)
+ ustlibs=
+ ustinc=
+ ;;
+ "" | yes)
+ ustlibs=" -lust "
+ ustinc=""
+ ;;
+ *)
+ ustlibs="-L$with_ust/lib -lust"
+ ustinc="-I$with_ust/include "
+ ;;
+esac
+if test "x$with_ust_include" != x; then
+ ustinc="-I$with_ust_include "
+fi
+if test "x$with_ust_lib" != x; then
+ ustlibs="-L$with_ust_lib -lust"
+fi
+
+if test "x$with_ust" != "xno"; then
+ saved_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS $ustinc"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ust" >&5
+$as_echo_n "checking for ust... " >&6; }
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+#define CONFIG_UST_GDB_INTEGRATION
+#include <ust/ust.h>
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; };
+$as_echo "#define HAVE_UST 1" >>confdefs.h
+
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }; ustlibs= ; ustinc=
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ CFLAGS="$saved_CFLAGS"
+fi
+
+# Flags needed for UST
+
+
+
old_LIBS="$LIBS"
LIBS="$LIBS -ldl"
for ac_func in dladdr
Index: src/gdb/gdbserver/linux-amd64-ipa.c
===================================================================
--- src.orig/gdb/gdbserver/linux-amd64-ipa.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/linux-amd64-ipa.c 2010-06-25 12:34:11.000000000 +0100
@@ -75,6 +75,95 @@ gdb_agent_get_raw_reg (const unsigned ch
return *(ULONGEST *) (raw_regs + x86_64_ft_collect_regmap[regnum]);
}
+#ifdef HAVE_UST
+
+#include <ust/processor.h>
+
+/* "struct registers" is the UST object type holding the registers at
+ the time of the static tracepoint marker call. This doesn't
+ contain RIP, but we know what it must have been (the marker
+ address). */
+
+#define ST_REGENTRY(REG) \
+ { \
+ offsetof (struct registers, REG), \
+ sizeof (((struct registers *) NULL)->REG) \
+ }
+
+static struct
+{
+ int offset;
+ int size;
+} x86_64_st_collect_regmap[] =
+ {
+ ST_REGENTRY(rax),
+ ST_REGENTRY(rbx),
+ ST_REGENTRY(rcx),
+ ST_REGENTRY(rdx),
+ ST_REGENTRY(rsi),
+ ST_REGENTRY(rdi),
+ ST_REGENTRY(rbp),
+ ST_REGENTRY(rsp),
+ ST_REGENTRY(r8),
+ ST_REGENTRY(r9),
+ ST_REGENTRY(r10),
+ ST_REGENTRY(r11),
+ ST_REGENTRY(r12),
+ ST_REGENTRY(r13),
+ ST_REGENTRY(r14),
+ ST_REGENTRY(r15),
+ { -1, 0 },
+ ST_REGENTRY(rflags),
+ ST_REGENTRY(cs),
+ ST_REGENTRY(ss),
+ };
+
+#define X86_64_NUM_ST_COLLECT_GREGS \
+ (sizeof (x86_64_st_collect_regmap) / sizeof (x86_64_st_collect_regmap[0]))
+
+/* GDB's RIP register number. */
+#define AMD64_RIP_REGNUM 16
+
+void
+supply_static_tracepoint_registers (struct regcache *regcache,
+ const unsigned char *buf,
+ CORE_ADDR pc)
+{
+ int i;
+ unsigned long newpc = pc;
+
+ supply_register (regcache, AMD64_RIP_REGNUM, &newpc);
+
+ for (i = 0; i < X86_64_NUM_ST_COLLECT_GREGS; i++)
+ if (x86_64_st_collect_regmap[i].offset != -1)
+ {
+ switch (x86_64_st_collect_regmap[i].size)
+ {
+ case 8:
+ supply_register (regcache, i,
+ ((char *) buf)
+ + x86_64_st_collect_regmap[i].offset);
+ break;
+ case 2:
+ {
+ unsigned long reg
+ = * (short *) (((char *) buf)
+ + x86_64_st_collect_regmap[i].offset);
+ reg &= 0xffff;
+ supply_register (regcache, i, ®);
+ }
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ "unhandled register size: %d",
+ x86_64_st_collect_regmap[i].size);
+ break;
+ }
+ }
+}
+
+#endif /* HAVE_UST */
+
/* This is only needed because reg-i386-linux-lib.o references it. We
may use it proper at some point. */
const char *gdbserver_xmltarget;
Index: src/gdb/gdbserver/linux-i386-ipa.c
===================================================================
--- src.orig/gdb/gdbserver/linux-i386-ipa.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/linux-i386-ipa.c 2010-06-25 12:33:50.000000000 +0100
@@ -110,6 +110,83 @@ gdb_agent_get_raw_reg (unsigned char *ra
return *(int *) (raw_regs + i386_ft_collect_regmap[regnum]);
}
+#ifdef HAVE_UST
+
+#include <ust/processor.h>
+
+/* "struct registers" is the UST object type holding the registers at
+ the time of the static tracepoint marker call. This doesn't
+ contain EIP, but we know what it must have been (the marker
+ address). */
+
+#define ST_REGENTRY(REG) \
+ { \
+ offsetof (struct registers, REG), \
+ sizeof (((struct registers *) NULL)->REG) \
+ }
+
+static struct
+{
+ int offset;
+ int size;
+} i386_st_collect_regmap[] =
+ {
+ ST_REGENTRY(eax),
+ ST_REGENTRY(ecx),
+ ST_REGENTRY(edx),
+ ST_REGENTRY(ebx),
+ ST_REGENTRY(esp),
+ ST_REGENTRY(ebp),
+ ST_REGENTRY(esi),
+ ST_REGENTRY(edi),
+ { -1, 0 }, /* eip */
+ ST_REGENTRY(eflags),
+ ST_REGENTRY(cs),
+ ST_REGENTRY(ss),
+ };
+
+#define i386_NUM_ST_COLLECT_GREGS \
+ (sizeof (i386_st_collect_regmap) / sizeof (i386_st_collect_regmap[0]))
+
+void
+supply_static_tracepoint_registers (struct regcache *regcache,
+ const unsigned char *buf,
+ CORE_ADDR pc)
+{
+ int i;
+ unsigned int newpc = pc;
+
+ supply_register (regcache, I386_EIP_REGNUM, &newpc);
+
+ for (i = 0; i < i386_NUM_ST_COLLECT_GREGS; i++)
+ if (i386_st_collect_regmap[i].offset != -1)
+ {
+ switch (i386_st_collect_regmap[i].size)
+ {
+ case 4:
+ supply_register (regcache, i,
+ ((char *) buf)
+ + i386_st_collect_regmap[i].offset);
+ break;
+ case 2:
+ {
+ unsigned long reg
+ = * (short *) (((char *) buf)
+ + i386_st_collect_regmap[i].offset);
+ reg &= 0xffff;
+ supply_register (regcache, i, ®);
+ }
+ break;
+ default:
+ internal_error ("unhandled register size: %d",
+ i386_st_collect_regmap[i].size);
+ }
+ }
+}
+
+#endif /* HAVE_UST */
+
+
/* This is only needed because reg-i386-linux-lib.o references it. We
may use it proper at some point. */
const char *gdbserver_xmltarget;
Index: src/gdb/gdbserver/server.c
===================================================================
--- src.orig/gdb/gdbserver/server.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/server.c 2010-06-25 16:36:16.000000000 +0100
@@ -1336,6 +1336,52 @@ handle_query (char *own_buf, int packet_
return;
}
+ if (strncmp ("qXfer:statictrace:read:", own_buf,
+ sizeof ("qXfer:statictrace:read:") -1) == 0)
+ {
+ unsigned char *data;
+ CORE_ADDR ofs;
+ unsigned int len;
+ char *annex;
+ ULONGEST nbytes;
+
+ require_running (own_buf);
+
+ if (current_traceframe == -1)
+ {
+ write_enn (own_buf);
+ return;
+ }
+
+ /* Reject any annex; grab the offset and length. */
+ if (decode_xfer_read (own_buf + sizeof ("qXfer:statictrace:read:") -1,
+ &annex, &ofs, &len) < 0
+ || annex[0] != '\0')
+ {
+ strcpy (own_buf, "E00");
+ return;
+ }
+
+ /* Read one extra byte, as an indicator of whether there is
+ more. */
+ if (len > PBUFSIZ - 2)
+ len = PBUFSIZ - 2;
+ data = malloc (len + 1);
+ if (!data)
+ return;
+
+ if (traceframe_read_sdata (current_traceframe, ofs,
+ data, len + 1, &nbytes))
+ write_enn (own_buf);
+ else if (nbytes > len)
+ *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
+ else
+ *new_packet_len_p = write_qxfer_response (own_buf, data, nbytes, 0);
+
+ free (data);
+ return;
+ }
+
/* Protocol features query. */
if (strncmp ("qSupported", own_buf, 10) == 0
&& (own_buf[10] == ':' || own_buf[10] == '\0'))
@@ -1433,6 +1479,8 @@ handle_query (char *own_buf, int packet_
strcat (own_buf, ";DisconnectedTracing+");
if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
strcat (own_buf, ";FastTracepoints+");
+ strcat (own_buf, ";StaticTracepoints+");
+ strcat (own_buf, ";qXfer:statictrace:read+");
}
return;
Index: src/gdb/mi/mi-cmd-break.c
===================================================================
--- src.orig/gdb/mi/mi-cmd-break.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/mi/mi-cmd-break.c 2010-06-25 12:01:29.000000000 +0100
@@ -75,6 +75,7 @@ mi_cmd_break_insert (char *command, char
int enabled = 1;
int tracepoint = 0;
struct cleanup *back_to;
+ enum bptype type_wanted;
enum opt
{
@@ -151,9 +152,21 @@ mi_cmd_break_insert (char *command, char
back_to = make_cleanup_restore_integer (&mi_can_breakpoint_notify);
mi_can_breakpoint_notify = 1;
+
+ /* Note that to request a fast tracepoint, the client uses the
+ "hardware" flag, although there's nothing of hardware related to
+ fast tracepoints -- one can implement slow tracepoints with
+ hardware breakpoints, but fast tracepoints are always software.
+ "fast" is a misnomer, actually, "jump" would be more appropriate.
+ A simulator or an emulator could conceivably implement fast
+ regular non-jump based tracepoints. */
+ type_wanted = (tracepoint
+ ? (hardware ? bp_fast_tracepoint : bp_tracepoint)
+ : (hardware ? bp_hardware_breakpoint : bp_breakpoint));
+
create_breakpoint (get_current_arch (), address, condition, thread,
0 /* condition and thread are valid. */,
- temp_p, hardware, tracepoint,
+ temp_p, type_wanted,
ignore_count,
pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE,
NULL, 0, enabled);
Index: src/gdb/remote.c
===================================================================
--- src.orig/gdb/remote.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/remote.c 2010-06-25 16:37:10.000000000 +0100
@@ -322,6 +322,9 @@ struct remote_state
/* True if the stub reports support for fast tracepoints. */
int fast_tracepoints;
+ /* True if the stub reports support for static tracepoints. */
+ int static_tracepoints;
+
/* True if the stub can continue running a trace while GDB is
disconnected. */
int disconnected_tracing;
@@ -1198,6 +1201,7 @@ enum {
PACKET_qXfer_spu_write,
PACKET_qXfer_osdata,
PACKET_qXfer_threads,
+ PACKET_qXfer_statictrace_read,
PACKET_qGetTIBAddr,
PACKET_qGetTLSAddr,
PACKET_qSupported,
@@ -1212,6 +1216,7 @@ enum {
PACKET_qAttached,
PACKET_ConditionalTracepoints,
PACKET_FastTracepoints,
+ PACKET_StaticTracepoints,
PACKET_bc,
PACKET_bs,
PACKET_TracepointSource,
@@ -2772,6 +2777,100 @@ remote_threads_extra_info (struct thread
}
+static int
+remote_static_tracepoint_marker_at (CORE_ADDR addr,
+ struct static_tracepoint_marker *marker)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p = rs->buf;
+
+ sprintf (p, "qTSTMat:");
+ p += strlen (p);
+ p += hexnumstr (p, addr);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+
+ if (*p == 'E')
+ error (_("Remote failure reply: %s"), p);
+
+ if (*p++ == 'm')
+ {
+ parse_static_tracepoint_marker_definition (p, &p, marker);
+ return 1;
+ }
+
+ return 0;
+}
+
+static int
+remote_static_tracepoint_marker_by_strid (const char *strid,
+ struct static_tracepoint_marker *marker)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p;
+
+ /* Ask for a first packet of static tracepoint marker
+ definition. */
+ putpkt ("qTfSTM");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ if (*p == 'E')
+ error (_("Remote failure reply: %s"), p);
+
+ while (*p++ == 'm')
+ {
+ do
+ {
+ parse_static_tracepoint_marker_definition (p, &p, marker);
+
+ if (strcmp (strid, marker->str_id) == 0)
+ return 1;
+
+ release_static_tracepoint_marker (marker);
+ }
+ while (*p++ == ','); /* comma-separated list */
+ /* Ask for another packet of static tracepoint definition. */
+ putpkt ("qTsSTM");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ }
+
+ return 0;
+}
+
+static void
+remote_list_static_tracepoint_markers (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p;
+
+ /* Ask for a first packet of static tracepoint definition. */
+ putpkt ("qTfSTM");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ if (*p == 'E')
+ error (_("Remote failure reply: %s"), p);
+
+ while (*p++ == 'm')
+ {
+ do
+ {
+ struct static_tracepoint_marker marker;
+
+ parse_static_tracepoint_marker_definition (p, &p, &marker);
+ print_one_static_tracepoint_marker (&marker);
+ release_static_tracepoint_marker (&marker);
+ }
+ while (*p++ == ','); /* comma-separated list */
+ /* Ask for another packet of static tracepoint definition. */
+ putpkt ("qTsSTM");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ }
+}
+
+
/* Implement the to_get_ada_task_ptid function for the remote targets. */
static ptid_t
@@ -3552,6 +3651,16 @@ remote_fast_tracepoint_feature (const st
}
static void
+remote_static_tracepoint_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ rs->static_tracepoints = (support == PACKET_ENABLE);
+}
+
+static void
remote_disconnected_tracing_feature (const struct protocol_feature *feature,
enum packet_support support,
const char *value)
@@ -3593,6 +3702,8 @@ static struct protocol_feature remote_pr
PACKET_ConditionalTracepoints },
{ "FastTracepoints", PACKET_DISABLE, remote_fast_tracepoint_feature,
PACKET_FastTracepoints },
+ { "StaticTracepoints", PACKET_DISABLE, remote_static_tracepoint_feature,
+ PACKET_StaticTracepoints },
{ "DisconnectedTracing", PACKET_DISABLE, remote_disconnected_tracing_feature,
-1 },
{ "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
@@ -8046,6 +8157,16 @@ remote_xfer_partial (struct target_ops *
[PACKET_qXfer_siginfo_write]);
}
+ if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
+ {
+ if (readbuf)
+ return remote_read_qxfer (ops, "statictrace", annex, readbuf, offset, len,
+ &remote_protocol_packets
+ [PACKET_qXfer_statictrace_read]);
+ else
+ return -1;
+ }
+
/* Only handle flash writes. */
if (writebuf != NULL)
{
@@ -9478,6 +9599,14 @@ remote_supports_fast_tracepoints (void)
return rs->fast_tracepoints;
}
+static int
+remote_supports_static_tracepoints (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->static_tracepoints;
+}
+
static void
remote_trace_init (void)
{
@@ -9606,6 +9735,25 @@ remote_download_tracepoint (struct break
give up on the trace run. */
warning (_("Target does not support fast tracepoints, downloading %d as regular tracepoint"), t->number);
}
+ else if (t->type == bp_static_tracepoint)
+ {
+ /* Only test for support at download time; we may not know
+ target capabilities at definition time. */
+ if (remote_supports_static_tracepoints ())
+ {
+ struct static_tracepoint_marker marker;
+
+ if (target_static_tracepoint_marker_at (tpaddr, &marker))
+ strcat (buf, ":S");
+ else
+ error ("Static tracepoint not valid during download");
+ }
+ else
+ /* Fast tracepoints are functionally identical to regular
+ tracepoints, so don't take lack of support as a reason
+ to give up on the trace run. */
+ error (_("Target does not support static tracepoints"));
+ }
/* If the tracepoint has a conditional, make it into an agent
expression and append to the definition. */
if (loc->cond)
@@ -10101,6 +10249,12 @@ Specify the serial device it is connecte
remote_ops.to_verify_memory = remote_verify_memory;
remote_ops.to_get_tib_address = remote_get_tib_address;
remote_ops.to_set_permissions = remote_set_permissions;
+ remote_ops.to_list_static_tracepoint_markers
+ = remote_list_static_tracepoint_markers;
+ remote_ops.to_static_tracepoint_marker_at
+ = remote_static_tracepoint_marker_at;
+ remote_ops.to_static_tracepoint_marker_by_strid
+ = remote_static_tracepoint_marker_by_strid;
}
/* Set up the extended remote vector by making a copy of the standard
@@ -10579,6 +10733,12 @@ Show the maximum size of the address (in
add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
"QAllow", "allow", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
+ "StaticTracepoints", "static-tracepoints", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
+ "qXfer:statictrace:read", "read-static-trace-object", 0);
+
/* Keep the old ``set remote Z-packet ...'' working. Each individual
Z sub-packet has its own set and show commands, but users may
have sets to this variable in their .gdbinit files (or in their
Index: src/gdb/target.c
===================================================================
--- src.orig/gdb/target.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/target.c 2010-06-25 12:01:29.000000000 +0100
@@ -679,6 +679,9 @@ update_current_target (void)
INHERIT (to_set_circular_trace_buffer, t);
INHERIT (to_get_tib_address, t);
INHERIT (to_set_permissions, t);
+ INHERIT (to_list_static_tracepoint_markers, t);
+ INHERIT (to_static_tracepoint_marker_at, t);
+ INHERIT (to_static_tracepoint_marker_by_strid, t);
INHERIT (to_magic, t);
/* Do not inherit to_memory_map. */
/* Do not inherit to_flash_erase. */
@@ -878,6 +881,15 @@ update_current_target (void)
de_fault (to_set_permissions,
(void (*) (void))
target_ignore);
+ de_fault (to_list_static_tracepoint_markers,
+ (void (*) (void))
+ target_ignore);
+ de_fault (to_static_tracepoint_marker_at,
+ (int (*) (CORE_ADDR, struct static_tracepoint_marker *))
+ return_zero);
+ de_fault (to_static_tracepoint_marker_by_strid,
+ (int (*) (const char *, struct static_tracepoint_marker *))
+ return_zero);
#undef de_fault
/* Finally, position the target-stack beneath the squashed
Index: src/gdb/target.h
===================================================================
--- src.orig/gdb/target.h 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/target.h 2010-06-25 12:01:29.000000000 +0100
@@ -35,6 +35,7 @@ struct trace_state_variable;
struct trace_status;
struct uploaded_tsv;
struct uploaded_tp;
+struct static_tracepoint_marker;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
@@ -261,6 +262,8 @@ enum target_object
TARGET_OBJECT_SIGNAL_INFO,
/* The list of threads that are being debugged. */
TARGET_OBJECT_THREADS,
+ /* Collected static trace data. */
+ TARGET_OBJECT_STATIC_TRACE_DATA,
/* Possible future objects: TARGET_OBJECT_FILE, ... */
};
@@ -689,6 +692,21 @@ struct target_ops
/* Send the new settings of write permission variables. */
void (*to_set_permissions) (void);
+ /* List static tracepoint markers in the target. Should call
+ print_one_static_tracepoint_marker for each marker. */
+ void (*to_list_static_tracepoint_markers) (void);
+
+ /* Look for a static tracepoint marker at ADDR, and fill in MARKER
+ with its details. Return 1 on success, 0 on failure. */
+ int (*to_static_tracepoint_marker_at) (CORE_ADDR,
+ struct static_tracepoint_marker *marker);
+
+ /* Look for a static tracepoint marker with string id ID, and fill
+ in MARKER with its details. Return 1 on success, 0 on
+ failure. */
+ int (*to_static_tracepoint_marker_by_strid) (const char *id,
+ struct static_tracepoint_marker *marker);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
@@ -1384,6 +1402,15 @@ extern int target_search_memory (CORE_AD
#define target_set_permissions() \
(*current_target.to_set_permissions) ()
+#define target_list_static_tracepoint_markers() \
+ (*current_target.to_list_static_tracepoint_markers) ()
+
+#define target_static_tracepoint_marker_at(addr, marker) \
+ (*current_target.to_static_tracepoint_marker_at) (addr, marker)
+
+#define target_static_tracepoint_marker_by_strid(marker_id, marker) \
+ (*current_target.to_static_tracepoint_marker_by_strid) (marker_id, marker)
+
/* Command logging facility. */
#define target_log_command(p) \
Index: src/gdb/tracepoint.c
===================================================================
--- src.orig/gdb/tracepoint.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/tracepoint.c 2010-06-25 15:28:03.000000000 +0100
@@ -47,7 +47,7 @@
#include "stack.h"
#include "gdbcore.h"
#include "remote.h"
-
+#include "source.h"
#include "ax.h"
#include "ax-gdb.h"
@@ -622,9 +622,10 @@ validate_actionline (char **line, struct
if (*p == '$') /* look for special pseudo-symbols */
{
- if ((0 == strncasecmp ("reg", p + 1, 3)) ||
- (0 == strncasecmp ("arg", p + 1, 3)) ||
- (0 == strncasecmp ("loc", p + 1, 3)))
+ if (0 == strncasecmp ("reg", p + 1, 3)
+ || 0 == strncasecmp ("arg", p + 1, 3)
+ || 0 == strncasecmp ("loc", p + 1, 3)
+ || 0 == strncasecmp ("_sdata", p + 1, 6))
{
p = strchr (p, ',');
continue;
@@ -747,6 +748,9 @@ struct collection_list
long next_aexpr_elt;
struct agent_expr **aexpr_list;
+ /* True is the user requested a collection of "$_sdata", "static
+ tracepoint data". */
+ int strace_data;
}
tracepoint_list, stepping_list;
@@ -1086,6 +1090,14 @@ add_local_symbols (struct collection_lis
}
}
+static void
+add_static_trace_data (struct collection_list *collection)
+{
+ if (info_verbose)
+ printf_filtered ("collect static trace data\n");
+ collection->strace_data = 1;
+}
+
/* worker function */
static void
clear_collection_list (struct collection_list *list)
@@ -1100,6 +1112,7 @@ clear_collection_list (struct collection
}
list->next_aexpr_elt = 0;
memset (list->regs_mask, 0, sizeof (list->regs_mask));
+ list->strace_data = 0;
}
/* reduce a collection list to string form (for gdb protocol) */
@@ -1114,9 +1127,19 @@ stringify_collection_list (struct collec
char *end;
long i;
- count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
+ count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
+ if (list->strace_data)
+ {
+ if (info_verbose)
+ printf_filtered ("\nCollecting static trace data\n");
+ end = temp_buf;
+ *end++ = 'L';
+ (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
+ ndx++;
+ }
+
for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
break;
@@ -1276,6 +1299,11 @@ encode_actions_1 (struct command_line *a
'L');
action_exp = strchr (action_exp, ','); /* more? */
}
+ else if (0 == strncasecmp ("$_sdata", action_exp, 7))
+ {
+ add_static_trace_data (collect);
+ action_exp = strchr (action_exp, ','); /* more? */
+ }
else
{
unsigned long addr, len;
@@ -3476,6 +3504,11 @@ parse_tracepoint_definition (char *line,
p++;
p = unpack_varlen_hex (p, &orig_size);
}
+ else if (*p == 'S')
+ {
+ type = bp_static_tracepoint;
+ p++;
+ }
else if (*p == 'X')
{
p++;
@@ -4075,12 +4108,239 @@ init_tfile_ops (void)
tfile_ops.to_magic = OPS_MAGIC;
}
+/* Given a line of text defining a static tracepoint marker, parse it
+ into a "static tracepoint marker" object. Throws an error is
+ parsing fails. If PP is non-null, it points to one past the end of
+ the parsed marker definition. */
+
+void
+parse_static_tracepoint_marker_definition (char *line, char **pp,
+ struct static_tracepoint_marker *marker)
+{
+ char *p, *endp;
+ ULONGEST addr;
+ int end;
+
+ p = line;
+ p = unpack_varlen_hex (p, &addr);
+ p++; /* skip a colon */
+
+ marker->gdbarch = target_gdbarch;
+ marker->address = (CORE_ADDR) addr;
+
+ endp = strchr (p, ':');
+ if (endp == NULL)
+ error ("bad marker definition: %s", line);
+
+ marker->str_id = xmalloc (endp - p + 1);
+ end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
+ marker->str_id[end] = '\0';
+
+ p += 2 * end;
+ p++; /* skip a colon */
+
+ marker->extra = xmalloc (strlen (p) + 1);
+ end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
+ marker->extra[end] = '\0';
+
+ if (pp)
+ *pp = p;
+}
+
+/* Release a static tracepoint marker's contents. Note that the
+ object itself isn't released here. There objects are usually on
+ the stack. */
+
+void
+release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
+{
+ xfree (marker->str_id);
+ marker->str_id = NULL;
+}
+
+/* Print MARKER to gdb_stdout. */
+
+void
+print_one_static_tracepoint_marker (struct static_tracepoint_marker *marker)
+{
+ struct command_line *l;
+ struct symbol *sym;
+
+ char wrap_indent[80];
+ struct ui_stream *stb = ui_out_stream_new (uiout);
+ struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
+ struct cleanup *bkpt_chain;
+ VEC(breakpoint_p) *tracepoints;
+
+ struct symtab_and_line sal;
+
+ init_sal (&sal);
+
+ sal.pc = marker->address;
+
+ tracepoints = static_tracepoints_here (marker->address);
+
+ bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
+
+ ui_out_field_fmt (uiout, "enabled", "%c",
+ !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
+ ui_out_spaces (uiout, 2);
+
+ strcpy (wrap_indent, " ");
+ if (gdbarch_addr_bit (marker->gdbarch) <= 32)
+ strcat (wrap_indent, " ");
+ else
+ strcat (wrap_indent, " ");
+
+ ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
+
+ sal = find_pc_line (marker->address, 0);
+ sym = find_pc_sect_function (marker->address, NULL);
+ if (sym)
+ {
+ ui_out_text (uiout, "in ");
+ ui_out_field_string (uiout, "func",
+ SYMBOL_PRINT_NAME (sym));
+ ui_out_wrap_hint (uiout, wrap_indent);
+ ui_out_text (uiout, " at ");
+ }
+ else
+ ui_out_field_skip (uiout, "func");
+
+ if (sal.symtab != NULL)
+ {
+ ui_out_field_string (uiout, "file", sal.symtab->filename);
+ ui_out_text (uiout, ":");
+
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ char *fullname = symtab_to_fullname (sal.symtab);
+
+ if (fullname)
+ ui_out_field_string (uiout, "fullname", fullname);
+ }
+ else
+ ui_out_field_skip (uiout, "fullname");
+
+ ui_out_field_int (uiout, "line", sal.line);
+ }
+ else
+ {
+ ui_out_field_skip (uiout, "fullname");
+ ui_out_field_skip (uiout, "line");
+ }
+ ui_out_text (uiout, "\n");
+
+ ui_out_text (uiout, _(" String ID: "));
+ ui_out_field_string (uiout, "original-location", marker->str_id);
+ ui_out_text (uiout, "\n");
+
+ ui_out_text (uiout, _(" Extra: "));
+ ui_out_field_string (uiout, "extra-data", marker->extra);
+ ui_out_text (uiout, "\n");
+
+ if (!VEC_empty (breakpoint_p, tracepoints))
+ {
+ struct cleanup *cleanup_chain;
+ int ix;
+ struct breakpoint *b;
+
+ cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
+ "tracepoints-at");
+
+ ui_out_text (uiout, _(" Probed by static tracepoints: "));
+ for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
+ {
+ if (ix > 0)
+ ui_out_text (uiout, ", ");
+ ui_out_text (uiout, "#");
+ ui_out_field_int (uiout, "tracepoint-id", b->number);
+ }
+
+ do_cleanups (cleanup_chain);
+
+ if (ui_out_is_mi_like_p (uiout))
+ ui_out_field_int (uiout, "number-of-tracepoints",
+ VEC_length(breakpoint_p, tracepoints));
+ else
+ ui_out_text (uiout, "\n");
+ }
+ VEC_free (breakpoint_p, tracepoints);
+
+ do_cleanups (bkpt_chain);
+ do_cleanups (old_chain);
+}
+
+static void
+info_static_tracepoint_markers_command (char *arg, int from_tty)
+{
+ struct cleanup *bkpttbl_chain;
+
+ bkpttbl_chain
+ = make_cleanup_ui_out_table_begin_end (uiout, 3, -1,
+ "StaticTracepointMarkersTable");
+
+ ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
+ if (gdbarch_addr_bit (target_gdbarch) <= 32)
+ ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
+ else
+ ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
+ ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
+ ui_out_table_body (uiout);
+
+ target_list_static_tracepoint_markers ();
+
+ do_cleanups (bkpttbl_chain);
+}
+
+/* The $_sdata convenience variable is a bit special. We don't know
+ for sure type of the value until we actually have a chance to fetch
+ the data --- the size of the object depends on what has been
+ collected. We solve this by making $_sdata be an internalvar that
+ creates a new value on access. */
+
+/* Return a new value with the correct type for the sdata object of
+ the current trace frame. Return a void value if there's no object
+ available. */
+
+static struct value *
+sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
+{
+ LONGEST size;
+ gdb_byte *buf;
+
+ /* We need to read the whole object before we know its size. */
+ size = target_read_alloc (¤t_target,
+ TARGET_OBJECT_STATIC_TRACE_DATA,
+ NULL, &buf);
+ if (size >= 0)
+ {
+ struct value *v;
+ struct type *type;
+
+ type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
+ size);
+ v = allocate_value (type);
+ memcpy (value_contents_raw (v), buf, size);
+ xfree (buf);
+ return v;
+ }
+ else
+ return allocate_value (builtin_type (gdbarch)->builtin_void);
+}
+
/* module initialization */
void
_initialize_tracepoint (void)
{
struct cmd_list_element *c;
+ /* Explicitly create without lookup, since that tries to create a
+ value with a void typed value, and when we get here, gdbarch
+ isn't initialized yet. At this point, we're quite sure there
+ isn't another convenience variable of the same name. */
+ create_internalvar_type_lazy ("_sdata", sdata_make_value);
+
traceframe_number = -1;
tracepoint_number = -1;
@@ -4143,6 +4403,11 @@ If no arguments are supplied, delete all
Status of trace state variables and their values.\n\
"));
+ add_info ("static-tracepoint-markers",
+ info_static_tracepoint_markers_command, _("\
+List target static tracepoints markers.\n\
+"));
+
add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
Select a trace frame;\n\
No argument means forward by one frame; '-' means backward by one frame."),
@@ -4223,6 +4488,7 @@ Also accepts the following special argum
$regs -- all registers.\n\
$args -- all function arguments.\n\
$locals -- all variables local to the block/function scope.\n\
+ $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
Note: this command can only be used in a tracepoint \"actions\" list."));
add_com ("teval", class_trace, teval_pseudocommand, _("\
Index: src/gdb/tracepoint.h
===================================================================
--- src.orig/gdb/tracepoint.h 2010-06-25 12:01:15.000000000 +0100
+++ src/gdb/tracepoint.h 2010-06-25 12:01:29.000000000 +0100
@@ -166,6 +166,26 @@ struct uploaded_tsv
struct uploaded_tsv *next;
};
+/* Struct recording info about a target static tracepoint marker. */
+
+struct static_tracepoint_marker
+{
+ struct gdbarch *gdbarch;
+ CORE_ADDR address;
+
+ /* The string ID of the marker. */
+ char *str_id;
+
+ /* Extra target reported info associated with the marker. */
+ char *extra;
+};
+
+extern void parse_static_tracepoint_marker_definition
+ (char *line, char **pp,
+ struct static_tracepoint_marker *marker);
+extern void print_one_static_tracepoint_marker (struct static_tracepoint_marker *);
+extern void release_static_tracepoint_marker (struct static_tracepoint_marker *);
+
/* A hook used to notify the UI of tracepoint operations. */
extern void (*deprecated_trace_find_hook) (char *arg, int from_tty);
Index: src/gdb/gdbserver/server.h
===================================================================
--- src.orig/gdb/gdbserver/server.h 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/gdbserver/server.h 2010-06-25 12:01:29.000000000 +0100
@@ -542,6 +542,10 @@ int fetch_traceframe_registers (int tfnu
struct regcache *regcache,
int regnum);
+int traceframe_read_sdata (int tfnum, ULONGEST offset,
+ unsigned char *buf, ULONGEST length,
+ ULONGEST *nbytes);
+
/* If a thread is determined to be collecting a fast tracepoint, this
structure holds the collect status. */
@@ -569,6 +573,9 @@ int handle_tracepoint_bkpts (struct thre
void initialize_low_tracepoint (void);
void supply_fast_tracepoint_registers (struct regcache *regcache,
const unsigned char *regs);
+void supply_static_tracepoint_registers (struct regcache *regcache,
+ const unsigned char *regs,
+ CORE_ADDR pc);
#else
void stop_tracing (void);
#endif
Index: src/gdb/python/py-breakpoint.c
===================================================================
--- src.orig/gdb/python/py-breakpoint.c 2010-06-25 12:01:14.000000000 +0100
+++ src/gdb/python/py-breakpoint.c 2010-06-25 12:01:29.000000000 +0100
@@ -592,7 +592,7 @@ bppy_new (PyTypeObject *subtype, PyObjec
create_breakpoint (python_gdbarch,
spec, NULL, -1,
0,
- 0, 0, 0,
+ 0, bp_breakpoint,
0,
AUTO_BOOLEAN_TRUE,
NULL, 0, 1);
Index: src/gdb/gdbserver/Makefile.in
===================================================================
--- src.orig/gdb/gdbserver/Makefile.in 2010-06-25 12:01:13.000000000 +0100
+++ src/gdb/gdbserver/Makefile.in 2010-06-25 12:01:29.000000000 +0100
@@ -197,7 +197,7 @@ gdbreplay$(EXEEXT): $(GDBREPLAY_OBS)
${CC-LD} $(INTERNAL_CFLAGS) $(INTERNAL_LDFLAGS) -o gdbreplay$(EXEEXT) $(GDBREPLAY_OBS) \
$(XM_CLIBS)
-IPA_OBJS=tracepoint-ipa.o utils-ipa.o regcache-ipa.o ${IPA_DEPFILES}
+IPA_OBJS=tracepoint-ipa.o utils-ipa.o regcache-ipa.o remote-utils-ipa.o ${IPA_DEPFILES}
IPA_LIB=libinproctrace.so
Index: src/gdb/gdbserver/remote-utils.c
===================================================================
--- src.orig/gdb/gdbserver/remote-utils.c 2010-06-25 12:01:13.000000000 +0100
+++ src/gdb/gdbserver/remote-utils.c 2010-06-25 12:01:29.000000000 +0100
@@ -74,6 +74,8 @@
typedef int socklen_t;
#endif
+#ifndef IN_PROCESS_AGENT
+
#if USE_WIN32API
# define INVALID_DESCRIPTOR INVALID_SOCKET
#else
@@ -371,6 +373,8 @@ fromhex (int a)
return 0;
}
+#endif
+
static const char hexchars[] = "0123456789abcdef";
static int
@@ -394,6 +398,8 @@ ishex (int ch, int *val)
return 0;
}
+#ifndef IN_PROCESS_AGENT
+
int
unhexify (char *bin, const char *hex, int count)
{
@@ -446,6 +452,8 @@ decode_address_to_semicolon (CORE_ADDR *
return end;
}
+#endif
+
/* Convert number NIB to a hex digit. */
static int
@@ -457,6 +465,8 @@ tohex (int nib)
return 'a' + nib - 10;
}
+#ifndef IN_PROCESS_AGENT
+
int
hexify (char *hex, const char *bin, int count)
{
@@ -600,6 +610,8 @@ try_rle (char *buf, int remaining, unsig
return n + 1;
}
+#endif
+
char *
unpack_varlen_hex (char *buff, /* packet to parse */
ULONGEST *result)
@@ -617,6 +629,8 @@ unpack_varlen_hex (char *buff, /* packet
return buff;
}
+#ifndef IN_PROCESS_AGENT
+
/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
char *
@@ -1126,6 +1140,8 @@ write_enn (char *buf)
buf[3] = '\0';
}
+#endif
+
void
convert_int_to_ascii (const unsigned char *from, char *to, int n)
{
@@ -1142,6 +1158,7 @@ convert_int_to_ascii (const unsigned cha
*to++ = 0;
}
+#ifndef IN_PROCESS_AGENT
void
convert_ascii_to_int (const char *from, unsigned char *to, int n)
@@ -1841,3 +1858,5 @@ buffer_xml_printf (struct buffer *buffer
buffer_grow_str (buffer, prev);
va_end (ap);
}
+
+#endif
Index: src/gdb/NEWS
===================================================================
--- src.orig/gdb/NEWS 2010-06-25 12:34:56.000000000 +0100
+++ src/gdb/NEWS 2010-06-25 15:25:20.000000000 +0100
@@ -12,6 +12,27 @@
thread-specific pointer to the TIB. This feature is also supported
when remote debugging using GDBserver.
+* Static tracepoints
+
+ Static tracepoints are calls in the user program into a tracing
+ library. One such library is a port of the LTTng kernel tracer to
+ userspace --- UST (LTTng Userspace Tracer). GDB, when debugging
+ with GDBserver, now supports combining the GDB tracepoint machinery
+ with such libraries. For example: the user can use GDB to probe a
+ static tracepoint marker (a call from the user program into the
+ tracing library) with the new "strace" command (see "New commands"
+ below). This creates a "static tracepoint" in the breakpoint list,
+ that can be manipulated with the same feature set as fast and
+ regular tracepoints. E.g., collect registers, local and global
+ variables, collect trace state variables, and define tracepoint
+ conditions. In addition, the user can collect extra static
+ tracepoint marker specific data, by collecting the new $_sdata
+ internal variable. When analying the trace buffer, you can inspect
+ $_sdata like any other variable available to GDB. For more
+ information, see the "Tracepoints" chapter in GDB user manual. New
+ remote packets have been defined to support static tracepoints, see
+ the "New remote packets" section below.
+
* New remote packets
qGetTIBAddr
@@ -27,23 +48,42 @@ qRelocInsn
is particularly useful for stubs that support fast tracepoints. GDB
reports support for this feature in the qSupported packet.
+qTfSTM, qTsSTM
+
+ List static tracepoint markers in the target program.
+
+qTSTMat
+
+ List static tracepoint markers at a given address in the target
+ program.
+
+qXfer:statictrace:read
+
+ Read the static trace data collected (by a `collect $_sdata'
+ tracepoint action). The remote stub reports support for this packet
+ to gdb's qSupported query.
+
* The source command now accepts a -s option to force searching for the
script in the source search path even if the script name specifies
a directory.
* New features in the GDB remote stub, GDBserver
- - GDBserver now support tracepoints (including fast tracepoints).
- The feature is currently supported by the i386-linux and
- amd64-linux builds. See the "Tracepoints support in gdbserver"
- section in the manual for more information. GDBserver JIT
- compiles the tracepoint's conditional agent expression bytecode
- into native code whenever possible for low overhead dynamic
- tracepoints conditionals. For such tracepoints, an expression
- that examines program state is evaluated when the tracepoint is
- reached, in order to determine whether to capture trace data. If
- the condition is simple and false, processing the tracepoint
- finishes very quickly and no data is gathered.
+ - GDBserver now support tracepoints (including fast tracepoints, and
+ static tracepoints). The feature is currently supported by the
+ i386-linux and amd64-linux builds. See the "Tracepoints support
+ in gdbserver" section in the manual for more information.
+
+ GDBserver JIT compiles the tracepoint's conditional agent
+ expression bytecode into native code whenever possible for low
+ overhead dynamic tracepoints conditionals. For such tracepoints,
+ an expression that examines program state is evaluated when the
+ tracepoint is reached, in order to determine whether to capture
+ trace data. If the condition is simple and false, processing the
+ tracepoint finishes very quickly and no data is gathered.
+
+ GDBserver interfaces with the UST (LTTng Userspace Tracer) library
+ for static tracepoints support.
- GDBserver now supports x86_64 Windows 64-bit debugging.
@@ -97,6 +137,13 @@ save breakpoints <filename>
`save tracepoints' is a new alias for `save-tracepoints'. The latter
is now deprecated.
+info static-tracepoint-markers
+ Display information about static tracepoint markers in the target.
+
+strace FN / FILE:LINE / *ADDR / -m MARKER_ID
+ Define a static tracepoint by probing a marker at the given
+ function, line, address, or MARKER_ID.
+
* Python scripting
** The GDB Python API now has access to breakpoints, symbols, symbol
Index: src/gdb/doc/gdb.texinfo
===================================================================
--- src.orig/gdb/doc/gdb.texinfo 2010-06-25 13:11:25.000000000 +0100
+++ src/gdb/doc/gdb.texinfo 2010-06-25 16:37:39.000000000 +0100
@@ -8279,6 +8279,13 @@ to match the format in which the data wa
The variable @code{$_exitcode} is automatically set to the exit code when
the program being debugged terminates.
+@item $_sdata
+@vindex $_sdata@r{, inspect, convenience variable}
+The variable @code{$_sdata} contains extra collected static tracepoint
+data. (@pxref{Tracepoint Actions,,Tracepoint Action Lists}). Note
+that @code{$_sdata} could be empty, if not inspecting a trace buffer,
+or extra static tracepoint data has not been collected.
+
@item $_siginfo
@vindex $_siginfo@r{, convenience variable}
The variable @code{$_siginfo} contains extra signal information
@@ -9590,6 +9597,21 @@ Some targets may support @dfn{fast trace
a different way (such as with a jump instead of a trap), that is
faster but possibly restricted in where they may be installed.
+Regular and fast tracepoints are dynamic tracing facilities, meaning
+that they can be used to insert tracepoints at (almost) any location
+in the target. Some targets may yet support controlling @dfn{static
+tracepoints} from @value{GDBN}. With static tracing, a set of
+instrumentation points, also known as @dfn{markers}, are embedded in
+the target program, and can be activated or deactivated by name or
+address. These are usually placed at locations which facilitate
+investigating what the target is actually doing. @value{GDBN}'s
+support for static tracing includes being able to list instrumentation
+points, and probe them with @value{GDBN} defined high level
+tracepoints that expose the whole range of convenience of
+@value{GDBN}'s tracepoints support. Namelly, support for collecting
+registers values and values of global or local (to the instrumentation
+point) variables; tracepoint conditions and trace state variables.
+
@code{gdbserver} supports tracepoints on some target systems.
@xref{Server,,Tracepoints support in @code{gdbserver}}.
@@ -9604,6 +9626,7 @@ conditions and actions.
* Trace State Variables::
* Tracepoint Actions::
* Listing Tracepoints::
+* Listing Static Tracepoint Markers::
* Starting and Stopping Trace Experiments::
* Tracepoint Restrictions::
@end menu
@@ -9663,6 +9686,27 @@ message.
@value{GDBN} handles arguments to @code{ftrace} exactly as for
@code{trace}.
+@item strace @var{location} [ if @var{cond} ]
+@cindex set static tracepoint
+@kindex strace
+The @code{strace} command sets a static tracepoint. For targets that
+support it, setting a static tracepoint probes a static
+instrumentation point, or marker, found at @var{location}. It may not
+be possible to set a static tracepoint at the desired location, in
+which case the command will exit with an explanatory message.
+
+@value{GDBN} handles arguments to @code{strace} exactly as for
+@code{trace}, with the addition that the user can also specify
+@code{-m @var{marker}} as @var{location}. This probes the marker
+identified by the @var{marker} string identifier.
+
+Static tracepoints accept an extra collect action --- @code{collect
+$_sdata}. This collects arbitrary user data passed in the probe point
+call to the tracing library. You can inspect this data when analysing
+the trace buffer, by printing the $_sdata variable like any other
+convenience variable. @xref{Tracepoint Actions,,Tracepoint Action
+Lists}.
+
@vindex $tpnum
@cindex last tracepoint number
@cindex recent tracepoint number
@@ -9899,13 +9943,29 @@ special arguments are supported:
@table @code
@item $regs
-collect all registers
+Collect all registers.
@item $args
-collect all function arguments
+Collect all function arguments.
@item $locals
-collect all local variables.
+Collect all local variables.
+
+@item $_sdata
+@vindex $_sdata@r{, collect}
+Collect static tracepoint marker specific data. Only available for
+static tracepoints. This usually consists of data formatted to a
+character string using the format provided by the programmer that
+instrumented the program. E.g., on some systems, an instrumentation
+point resembles a printf function call:
+
+@smallexample
+ TRACE(tp1, "hello %s", master_name)
+@end smallexample
+
+Collecting @code{$_sdata} in this case collects the string @samp{hello
+$yourname}. When analying the trace buffer, you can inspect
+@samp{$_sdata} like any other variable available to @value{GDBN}.
@end table
You can give several consecutive @code{collect} commands, each one
@@ -10000,6 +10060,30 @@ Num Type Disp Enb Address
This command can be abbreviated @code{info tp}.
@end table
+@node Listing Static Tracepoint Markers
+@subsection Listing Static Tracepoint Markers
+
+@table @code
+@kindex info static-tracepoint-markers
+@cindex information about static tracepoint markers in the target program.
+@item info static-tracepoint-markers
+Display information about all static tracepoint markers defined in the
+program.
+
+@smallexample
+(@value{GDBP}) info static-tracepoint-markers
+Enb Address What
+y 0x0000000000400e1a in main at stexample.c:25
+ String ID: ust/bar2
+ Extra: number1 %d number2 %d
+ Probed by static tracepoints: #2
+n 0x0000000000400c87 in main at stexample.c:24
+ String ID: ust/bar33
+ Extra: str %s
+(@value{GDBP})
+@end smallexample
+@end table
+
@node Starting and Stopping Trace Experiments
@subsection Starting and Stopping Trace Experiments
@@ -15848,13 +15932,21 @@ of a multi-process mode debug session.
@subsection Tracepoints support in @code{gdbserver}
@cindex tracepoints support in @code{gdbserver}
-On some targets, @code{gdbserver} supports tracepoints and fast
-tracepoints.
+On some targets, @code{gdbserver} supports tracepoints, fast
+tracepoints and static tracepoints.
-For fast tracepoints to work, a special library called the
+For fast or static tracepoints to work, a special library called the
@dfn{in-process agent} (IPA), must be loaded in the inferior process.
This library is built and distributed as an integral part of
-@code{gdbserver}.
+@code{gdbserver}. In addition, support for static tracepoints
+requires building the in-process agent library with static tracepoints
+support. At present, the UST (LTTng Userspace Tracer,
+@url{http://lttng.org}) tracing engine is supported. This support is
+automatically available if UST development headers are found in the
+standard include path when @code{gdbserver} is built, or if
+@code{gdbserver} was explicitly configured using @option{--with-ust}
+to point at such headers. You can explicitly disable the support
+using @option{--with-ust=no}.
There are several ways to load the in-process agent in your program:
@@ -15895,10 +15987,10 @@ systems, when you connect to @code{gdbse
remote}, you'll find that the program is stopped at the dynamic
loader's entry point, and no shared library has been loaded in the
program's address space yet, including the in-process agent. In that
-case, before being able to use any of the fast tracepoints features,
-you need to let the loader run and load the shared libraries. The
-most simple way to do that is to run the program to the main
-procedure. E.g., if debugging a C or C@t{++} program, start
+case, before being able to use any of the fast or static tracepoints
+features, you need to let the loader run and load the shared
+libraries. The most simple way to do that is to run the program to
+the main procedure. E.g., if debugging a C or C@t{++} program, start
@code{gdbserver} like so:
@smallexample
@@ -15918,7 +16010,8 @@ $ gdb myprogram
The in-process tracing agent library should now be loaded into the
process; you can confirm it with the @code{info sharedlibrary}
command, which will list @file{libinproctrace.so} as loaded in the
-process. You are now ready to install fast tracepoints and start
+process. You are now ready to install fast tracepoints, list static
+tracepoint markers, probe static tracepoints markers, and start
tracing.
@node Remote Configuration
@@ -16170,6 +16263,10 @@ are:
@tab @code{qXfer:memory-map:read}
@tab @code{info mem}
+@item @code{read-sdata-object}
+@tab @code{qXfer:sdata:read}
+@tab @code{print $_sdata}
+
@item @code{read-spu-object}
@tab @code{qXfer:spu:read}
@tab @code{info spu}
@@ -31807,6 +31904,11 @@ These are the currently defined stub fea
@tab @samp{-}
@tab Yes
+@item @samp{qXfer:sdata:read}
+@tab No
+@tab @samp{-}
+@tab Yes
+
@item @samp{qXfer:spu:read}
@tab No
@tab @samp{-}
@@ -31910,6 +32012,10 @@ The remote stub understands the @samp{qX
The remote stub understands the @samp{qXfer:memory-map:read} packet
(@pxref{qXfer memory map read}).
+@item qXfer:sdata:read
+The remote stub understands the @samp{qXfer:sdata:read} packet
+(@pxref{qXfer sdata read}).
+
@item qXfer:spu:read
The remote stub understands the @samp{qXfer:spu:read} packet
(@pxref{qXfer spu read}).
@@ -31978,6 +32084,10 @@ the source form of tracepoint definition
@item QAllow
The remote stub understands the @samp{QAllow} packet.
+@item StaticTracepoint
+@cindex static tracepoints, in remote protocol
+The remote stub supports static tracepoints.
+
@end table
@item qSymbol::
@@ -32062,6 +32172,9 @@ packets.)
@itemx QTro
@itemx qTStatus
@itemx qTV
+@itemx qTfSTM
+@itemx qTsSTM
+@itemx qTSTMat
@xref{Tracepoint Packets}.
@item qXfer:@var{object}:read:@var{annex}:@var{offset},@var{length}
@@ -32118,6 +32231,18 @@ annex part of the generic @samp{qXfer} p
This packet is not probed by default; the remote stub must request it,
by supplying an appropriate @samp{qSupported} response (@pxref{qSupported}).
+@item qXfer:sdata:read::@var{offset},@var{length}
+@anchor{qXfer sdata read}
+
+Read contents of the extra collected static tracepoint marker
+information. The annex part of the generic @samp{qXfer} packet must
+be empty (@pxref{qXfer read}). @xref{Tracepoint Actions,,Tracepoint
+Action Lists}.
+
+This packet is not probed by default; the remote stub must request it,
+by supplying an appropriate @samp{qSupported} response
+(@pxref{qSupported}).
+
@item qXfer:siginfo:read::@var{offset},@var{length}
@anchor{qXfer siginfo read}
Read contents of the extra signal information on the target
@@ -32657,6 +32782,38 @@ and multiple @code{qTsV} to get addition
these packets follow the syntax of the @code{QTDV} packets that define
trace state variables.
+@item qTfSTM
+@itemx qTsSTM
+These packets request data about static tracepoint markers that exist
+in the target program. @value{GDBN} sends @code{qTfSTM} to get the
+first piece of data, and multiple @code{qTsSTM} to get additional
+pieces. Replies to these packets take the following form:
+
+Reply:
+@table @samp
+@item m @var{address}:@var{id}:@var{extra}
+A single marker
+@item m @var{address}:@var{id}:@var{extra},@var{address}:@var{id}:@var{extra}@dots{}
+a comma-separated list of markers
+@item l
+(lower case letter @samp{L}) denotes end of list.
+@end table
+
+@var{address} is encoded in hex.
+@var{id} and @var{extra} are strings encoded in hex.
+
+In response to each query, the target will reply with a list of one or
+more markers, separated by commas. @value{GDBN} will respond to each
+reply with a request for more markers (using the @samp{qs} form of the
+query), until the target responds with @samp{l} (lower-case el, for
+@dfn{last}).
+
+@item qTSTMat:@var{address}
+This packets requests data about static tracepoint markers in the
+target program at @var{address}. Replies to this packet follow the
+syntax of the @samp{qTfSTM} and @code{qTsSTM} packets that list static
+tracepoint markers.
+
@item QTSave:@var{filename}
This packet directs the target to save trace data to the file name
@var{filename} in the target's filesystem. @var{filename} is encoded