From b955b4d4c416bfa4db1915b51834c24ee2f35df1 Mon Sep 17 00:00:00 2001 From: Francis Deslauriers Date: Fri, 29 Jun 2018 15:28:30 -0400 Subject: [PATCH] Implement lttng-list for userspace-probe MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Here is an example of the output of the list command for a ELF function userspace probe: ``` Event rules: userspace_probe_test_event (type: userspace-probe) [enabled] Type: Function Binary path: /home/frdeso/projets/lttng/tools/tests/utils/testapp/userspace-probe-elf-binary/userspace-probe-elf-binary Function: test_function() Lookup method: ELF ``` Signed-off-by: Francis Deslauriers Signed-off-by: Jérémie Galarneau --- src/bin/lttng-sessiond/cmd.c | 3 ++ src/bin/lttng/commands/list.c | 79 +++++++++++++++++++++++++++++++++++ 2 files changed, 82 insertions(+) diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index f9e2bd686..4ae8a1a35 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -769,6 +769,9 @@ static int list_lttng_kernel_events(char *channel_name, memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; + case LTTNG_KERNEL_UPROBE: + (*events)[i].type = LTTNG_EVENT_USERSPACE_PROBE; + break; case LTTNG_KERNEL_FUNCTION: (*events)[i].type = LTTNG_EVENT_FUNCTION; memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, diff --git a/src/bin/lttng/commands/list.c b/src/bin/lttng/commands/list.c index 4a94690b0..be252ab76 100644 --- a/src/bin/lttng/commands/list.c +++ b/src/bin/lttng/commands/list.c @@ -249,6 +249,82 @@ end: return exclusion_msg; } +static void print_userspace_probe_location(struct lttng_event *event) +{ + struct lttng_userspace_probe_location *location; + struct lttng_userspace_probe_location_lookup_method *lookup_method; + enum lttng_userspace_probe_location_lookup_method_type lookup_type; + + location = lttng_event_get_userspace_probe_location(event); + if (!location) { + MSG("Event has no userspace probe location"); + return; + } + + lookup_method = lttng_userspace_probe_location_get_lookup_method(location); + if (!lookup_method) { + MSG("Event has no userspace probe location lookup method"); + return; + } + + MSG("%s%s (type: userspace-probe)%s", indent6, event->name, enabled_string(event->enabled)); + + lookup_type = lttng_userspace_probe_location_lookup_method_get_type(lookup_method); + + switch (lttng_userspace_probe_location_get_type(location)) { + case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN: + MSG("%sType: Unknown", indent8); + break; + case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION: + { + const char *function_name; + const char *binary_path; + + MSG("%sType: Function", indent8); + function_name = lttng_userspace_probe_location_function_get_function_name(location); + binary_path = realpath(lttng_userspace_probe_location_function_get_binary_path(location), NULL); + + MSG("%sBinary path: %s", indent8, binary_path ? binary_path : "NULL"); + MSG("%sFunction: %s()", indent8, function_name ? function_name : "NULL"); + switch (lookup_type) { + case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: + MSG("%sLookup method: ELF", indent8); + break; + case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT: + MSG("%sLookup method: default", indent8); + break; + default: + MSG("%sLookup method: INVALID LOOKUP TYPE ENCOUNTERED", indent8); + break; + } + break; + } + case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT: + { + const char *probe_name, *provider_name; + const char *binary_path; + + MSG("%sType: Tracepoint", indent8); + probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(location); + provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(location); + binary_path = realpath(lttng_userspace_probe_location_tracepoint_get_binary_path(location), NULL); + MSG("%sBinary path: %s", indent8, binary_path ? binary_path : "NULL"); + MSG("%sTracepoint: %s:%s", indent8, provider_name ? provider_name : "NULL", probe_name ? probe_name : "NULL"); + switch (lookup_type) { + case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT: + MSG("%sLookup method: SDT", indent8); + break; + default: + MSG("%sLookup method: INVALID LOOKUP TYPE ENCOUNTERED", indent8); + break; + } + break; + } + default: + ERR("Invalid probe type encountered"); + } +} + /* * Pretty print single event. */ @@ -324,6 +400,9 @@ static void print_events(struct lttng_event *event) MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name); } break; + case LTTNG_EVENT_USERSPACE_PROBE: + print_userspace_probe_location(event); + break; case LTTNG_EVENT_FUNCTION_ENTRY: MSG("%s%s (type: function)%s%s", indent6, event->name, enabled_string(event->enabled), -- 2.34.1