X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Flist.c;h=8151886082857a383f93e3d8d9ae72b69eae7bd4;hp=8e69e09efdc6bb85be8206a05d2d703a606f7ab0;hb=41493f4a4a33b280a8e17b193af1bebf50ccb694;hpb=fb83fe64f250bec7416f18891a8264450c61ead3 diff --git a/src/bin/lttng/commands/list.c b/src/bin/lttng/commands/list.c index 8e69e09ef..815188608 100644 --- a/src/bin/lttng/commands/list.c +++ b/src/bin/lttng/commands/list.c @@ -1,20 +1,12 @@ /* - * Copyright (C) 2011 - David Goulet + * Copyright (C) 2011 David Goulet + * Copyright (C) 2020 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include #define _LGPL_SOURCE #include #include @@ -24,7 +16,9 @@ #include #include -#include +#include +#include +#include #include "../command.h" @@ -42,14 +36,23 @@ const char *indent4 = " "; const char *indent6 = " "; const char *indent8 = " "; +#ifdef LTTNG_EMBED_HELP +static const char help_msg[] = +#include +; +#endif + enum { OPT_HELP = 1, OPT_USERSPACE, OPT_LIST_OPTIONS, }; -static struct lttng_handle *handle; -static struct mi_writer *writer; +static struct lttng_handle *the_handle; +static struct mi_writer *the_writer; + +/* Only set when listing a single session. */ +static struct lttng_session the_listed_session; static struct poptOption long_options[] = { /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */ @@ -67,34 +70,6 @@ static struct poptOption long_options[] = { {0, 0, 0, 0, 0, 0, 0} }; -/* - * usage - */ -static void usage(FILE *ofp) -{ - fprintf(ofp, "usage: lttng list [OPTIONS] [SESSION [SESSION OPTIONS]]\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "With no arguments, list available tracing session(s)\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "Without a session, -k lists available kernel events\n"); - fprintf(ofp, "Without a session, -u lists available userspace events\n"); - fprintf(ofp, "\n"); - fprintf(ofp, " -h, --help Show this help\n"); - fprintf(ofp, " --list-options Simple listing of options\n"); - fprintf(ofp, " -k, --kernel Select kernel domain\n"); - fprintf(ofp, " -u, --userspace Select user-space domain.\n"); - fprintf(ofp, " -j, --jul Apply for Java application using JUL\n"); - fprintf(ofp, " -l, --log4j Apply for Java application using LOG4J\n"); - fprintf(ofp, " -p, --python Apply for Python application using logging\n"); - fprintf(ofp, " -f, --fields List event fields.\n"); - fprintf(ofp, " --syscall List available system calls.\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "Session Options:\n"); - fprintf(ofp, " -c, --channel NAME List details of a channel\n"); - fprintf(ofp, " -d, --domain List available domain(s)\n"); - fprintf(ofp, "\n"); -} - /* * Get command line from /proc for a specific pid. * @@ -268,6 +243,86 @@ end: return exclusion_msg; } +static void print_userspace_probe_location(struct lttng_event *event) +{ + const struct lttng_userspace_probe_location *location; + const 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; + 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; + } + + free(binary_path); + break; + } + case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT: + { + const char *probe_name, *provider_name; + 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; + } + + free(binary_path); + break; + } + default: + ERR("Invalid probe type encountered"); + } +} + /* * Pretty print single event. */ @@ -278,7 +333,7 @@ static void print_events(struct lttng_event *event) char *filter_msg = NULL; char *exclusion_msg = NULL; - ret = lttng_event_get_filter_string(event, &filter_str); + ret = lttng_event_get_filter_expression(event, &filter_str); if (ret) { filter_msg = strdup(" [failed to retrieve filter]"); @@ -303,14 +358,16 @@ static void print_events(struct lttng_event *event) { if (event->loglevel != -1) { MSG("%s%s (loglevel%s %s (%d)) (type: tracepoint)%s%s%s", - indent6, - event->name, - logleveltype_string(event->loglevel_type), - mi_lttng_loglevel_string(event->loglevel, handle->domain.type), - event->loglevel, - enabled_string(event->enabled), - safe_string(exclusion_msg), - safe_string(filter_msg)); + indent6, event->name, + logleveltype_string( + event->loglevel_type), + mi_lttng_loglevel_string( + event->loglevel, + the_handle->domain.type), + event->loglevel, + enabled_string(event->enabled), + safe_string(exclusion_msg), + safe_string(filter_msg)); } else { MSG("%s%s (type: tracepoint)%s%s%s", indent6, @@ -343,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), @@ -350,10 +410,11 @@ static void print_events(struct lttng_event *event) MSG("%ssymbol: \"%s\"", indent8, event->attr.ftrace.symbol_name); break; case LTTNG_EVENT_SYSCALL: - MSG("%s%s%s%s%s", indent6, event->name, + MSG("%s%s%s%s%s%s", indent6, event->name, (opt_syscall ? "" : " (type:syscall)"), enabled_string(event->enabled), - bitness_event(event->flags)); + bitness_event(event->flags), + safe_string(filter_msg)); break; case LTTNG_EVENT_NOOP: MSG("%s (type: noop)%s%s", indent6, @@ -361,6 +422,8 @@ static void print_events(struct lttng_event *event) safe_string(filter_msg)); break; case LTTNG_EVENT_ALL: + /* Fall-through. */ + default: /* We should never have "all" events in list. */ assert(0); break; @@ -412,19 +475,19 @@ static int mi_list_agent_ust_events(struct lttng_event *events, int count, int pid_element_open = 0; /* Open domains element */ - ret = mi_lttng_domains_open(writer); + ret = mi_lttng_domains_open(the_writer); if (ret) { goto end; } /* Write domain */ - ret = mi_lttng_domain(writer, domain, 1); + ret = mi_lttng_domain(the_writer, domain, 1); if (ret) { goto end; } /* Open pids element element */ - ret = mi_lttng_pids_open(writer); + ret = mi_lttng_pids_open(the_writer); if (ret) { goto end; } @@ -433,7 +496,8 @@ static int mi_list_agent_ust_events(struct lttng_event *events, int count, if (cur_pid != events[i].pid) { if (pid_element_open) { /* Close the previous events and pid element */ - ret = mi_lttng_close_multi_element(writer, 2); + ret = mi_lttng_close_multi_element( + the_writer, 2); if (ret) { goto end; } @@ -449,13 +513,14 @@ static int mi_list_agent_ust_events(struct lttng_event *events, int count, if (!pid_element_open) { /* Open and write a pid element */ - ret = mi_lttng_pid(writer, cur_pid, cmdline, 1); + ret = mi_lttng_pid(the_writer, cur_pid, cmdline, + 1); if (ret) { goto error; } /* Open events element */ - ret = mi_lttng_events_open(writer); + ret = mi_lttng_events_open(the_writer); if (ret) { goto error; } @@ -466,20 +531,21 @@ static int mi_list_agent_ust_events(struct lttng_event *events, int count, } /* Write an event */ - ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, + the_handle->domain.type); if (ret) { goto end; } } /* Close pids */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto end; } /* Close domain, domains */ - ret = mi_lttng_close_multi_element(writer, 2); + ret = mi_lttng_close_multi_element(the_writer, 2); end: return ret; error: @@ -648,20 +714,22 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, int event_element_open = 0; struct lttng_event cur_event; + memset(&cur_event, 0, sizeof(cur_event)); + /* Open domains element */ - ret = mi_lttng_domains_open(writer); + ret = mi_lttng_domains_open(the_writer); if (ret) { goto end; } /* Write domain */ - ret = mi_lttng_domain(writer, domain, 1); + ret = mi_lttng_domain(the_writer, domain, 1); if (ret) { goto end; } /* Open pids element */ - ret = mi_lttng_pids_open(writer); + ret = mi_lttng_pids_open(the_writer); if (ret) { goto end; } @@ -670,16 +738,17 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, if (cur_pid != fields[i].event.pid) { if (pid_element_open) { if (event_element_open) { - /* Close the previous field element and event. */ - ret = mi_lttng_close_multi_element(writer, 2); + ret = mi_lttng_close_multi_element( + the_writer, 2); if (ret) { goto end; } event_element_open = 0; } /* Close the previous events, pid element */ - ret = mi_lttng_close_multi_element(writer, 2); + ret = mi_lttng_close_multi_element( + the_writer, 2); if (ret) { goto end; } @@ -690,13 +759,14 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, cmdline = get_cmdline_by_pid(cur_pid); if (!pid_element_open) { /* Open and write a pid element */ - ret = mi_lttng_pid(writer, cur_pid, cmdline, 1); + ret = mi_lttng_pid(the_writer, cur_pid, cmdline, + 1); if (ret) { goto error; } /* Open events element */ - ret = mi_lttng_events_open(writer); + ret = mi_lttng_events_open(the_writer); if (ret) { goto error; } @@ -710,7 +780,8 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, if (strcmp(cur_event.name, fields[i].event.name) != 0) { if (event_element_open) { /* Close the previous fields element and the previous event */ - ret = mi_lttng_close_multi_element(writer, 2); + ret = mi_lttng_close_multi_element( + the_writer, 2); if (ret) { goto end; } @@ -722,14 +793,14 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, if (!event_element_open) { /* Open and write the event */ - ret = mi_lttng_event(writer, &cur_event, 1, - handle->domain.type); + ret = mi_lttng_event(the_writer, &cur_event, 1, + the_handle->domain.type); if (ret) { goto end; } /* Open a fields element */ - ret = mi_lttng_event_fields_open(writer); + ret = mi_lttng_event_fields_open(the_writer); if (ret) { goto end; } @@ -738,14 +809,14 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, } /* Print the event_field */ - ret = mi_lttng_event_field(writer, &fields[i]); + ret = mi_lttng_event_field(the_writer, &fields[i]); if (ret) { goto end; } } - /* Close pid, domain, domains */ - ret = mi_lttng_close_multi_element(writer, 3); + /* Close pids, domain, domains */ + ret = mi_lttng_close_multi_element(the_writer, 3); end: return ret; error: @@ -843,32 +914,33 @@ static int mi_list_kernel_events(struct lttng_event *events, int count, int ret, i; /* Open domains element */ - ret = mi_lttng_domains_open(writer); + ret = mi_lttng_domains_open(the_writer); if (ret) { goto end; } /* Write domain */ - ret = mi_lttng_domain(writer, domain, 1); + ret = mi_lttng_domain(the_writer, domain, 1); if (ret) { goto end; } /* Open events */ - ret = mi_lttng_events_open(writer); + ret = mi_lttng_events_open(the_writer); if (ret) { goto end; } for (i = 0; i < count; i++) { - ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, + the_handle->domain.type); if (ret) { goto end; } } /* close events, domain and domains */ - ret = mi_lttng_close_multi_element(writer, 3); + ret = mi_lttng_close_multi_element(the_writer, 3); if (ret) { goto end; } @@ -943,20 +1015,21 @@ static int mi_list_syscalls(struct lttng_event *events, int count) int ret, i; /* Open events */ - ret = mi_lttng_events_open(writer); + ret = mi_lttng_events_open(the_writer); if (ret) { goto end; } for (i = 0; i < count; i++) { - ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, + the_handle->domain.type); if (ret) { goto end; } } /* Close events. */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto end; } @@ -1016,20 +1089,21 @@ static int mi_list_session_agent_events(struct lttng_event *events, int count) int ret, i; /* Open events element */ - ret = mi_lttng_events_open(writer); + ret = mi_lttng_events_open(the_writer); if (ret) { goto end; } for (i = 0; i < count; i++) { - ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, + the_handle->domain.type); if (ret) { goto end; } } /* Close events element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); end: return ret; @@ -1045,7 +1119,7 @@ static int list_session_agent_events(void) int ret = CMD_SUCCESS, count, i; struct lttng_event *events = NULL; - count = lttng_list_events(handle, "", &events); + count = lttng_list_events(the_handle, "", &events); if (count < 0) { ret = CMD_ERROR; ERR("%s", lttng_strerror(count)); @@ -1072,7 +1146,8 @@ static int list_session_agent_events(void) char *filter_msg = NULL; struct lttng_event *event = &events[i]; - ret = lttng_event_get_filter_string(event, &filter_str); + ret = lttng_event_get_filter_expression(event, + &filter_str); if (ret) { filter_msg = strdup(" [failed to retrieve filter]"); } else if (filter_str) { @@ -1093,10 +1168,11 @@ static int list_session_agent_events(void) event->name, enabled_string(event->enabled), logleveltype_string( - event->loglevel_type), + event->loglevel_type), mi_lttng_loglevel_string( - event->loglevel, - handle->domain.type), + event->loglevel, + the_handle->domain + .type), safe_string(filter_msg)); } else { MSG("%s- %s%s%s", indent4, event->name, @@ -1124,20 +1200,21 @@ static int mi_list_events(struct lttng_event *events, int count) int ret, i; /* Open events element */ - ret = mi_lttng_events_open(writer); + ret = mi_lttng_events_open(the_writer); if (ret) { goto end; } for (i = 0; i < count; i++) { - ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, + the_handle->domain.type); if (ret) { goto end; } } /* Close events element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); end: return ret; @@ -1151,7 +1228,7 @@ static int list_events(const char *channel_name) int ret = CMD_SUCCESS, count, i; struct lttng_event *events = NULL; - count = lttng_list_events(handle, channel_name, &events); + count = lttng_list_events(the_handle, channel_name, &events); if (count < 0) { ret = CMD_ERROR; ERR("%s", lttng_strerror(count)); @@ -1167,7 +1244,7 @@ static int list_events(const char *channel_name) } } else { /* Pretty print */ - MSG("\n%sEvents:", indent4); + MSG("\n%sEvent rules:", indent4); if (count == 0) { MSG("%sNone\n", indent6); goto end; @@ -1185,13 +1262,31 @@ error: return ret; } +static +void print_timer(const char *timer_name, uint32_t space_count, int64_t value) +{ + uint32_t i; + + _MSG("%s%s:", indent6, timer_name); + for (i = 0; i < space_count; i++) { + _MSG(" "); + } + + if (value) { + MSG("%" PRId64 " %s", value, USEC_UNIT); + } else { + MSG("inactive"); + } +} + /* * Pretty print channel */ static void print_channel(struct lttng_channel *channel) { int ret; - uint64_t discarded_events, lost_packets; + uint64_t discarded_events, lost_packets, monitor_timer_interval; + int64_t blocking_timeout; ret = lttng_channel_get_discarded_event_count(channel, &discarded_events); @@ -1207,26 +1302,83 @@ static void print_channel(struct lttng_channel *channel) return; } - MSG("- %s:%s\n", channel->name, enabled_string(channel->enabled)); + ret = lttng_channel_get_monitor_timer_interval(channel, + &monitor_timer_interval); + if (ret) { + ERR("Failed to retrieve monitor interval of channel"); + return; + } + ret = lttng_channel_get_blocking_timeout(channel, + &blocking_timeout); + if (ret) { + ERR("Failed to retrieve blocking timeout of channel"); + return; + } + + MSG("- %s:%s\n", channel->name, enabled_string(channel->enabled)); MSG("%sAttributes:", indent4); - MSG("%soverwrite mode: %d", indent6, channel->attr.overwrite); - MSG("%ssubbufers size: %" PRIu64, indent6, channel->attr.subbuf_size); - MSG("%snumber of subbufers: %" PRIu64, indent6, channel->attr.num_subbuf); - MSG("%sswitch timer interval: %u", indent6, channel->attr.switch_timer_interval); - MSG("%sread timer interval: %u", indent6, channel->attr.read_timer_interval); - MSG("%strace file count: %" PRIu64, indent6, channel->attr.tracefile_count); - MSG("%strace file size (bytes): %" PRIu64, indent6, channel->attr.tracefile_size); - MSG("%sdiscarded events: %" PRIu64, indent6, discarded_events); - MSG("%slost packets: %" PRIu64, indent6, lost_packets); + MSG("%sEvent-loss mode: %s", indent6, channel->attr.overwrite ? "overwrite" : "discard"); + MSG("%sSub-buffer size: %" PRIu64 " bytes", indent6, channel->attr.subbuf_size); + MSG("%sSub-buffer count: %" PRIu64, indent6, channel->attr.num_subbuf); + + print_timer("Switch timer", 5, channel->attr.switch_timer_interval); + print_timer("Read timer", 7, channel->attr.read_timer_interval); + print_timer("Monitor timer", 4, monitor_timer_interval); + + if (!channel->attr.overwrite) { + if (blocking_timeout == -1) { + MSG("%sBlocking timeout: infinite", indent6); + } else { + MSG("%sBlocking timeout: %" PRId64 " %s", indent6, + blocking_timeout, USEC_UNIT); + } + } + + MSG("%sTrace file count: %" PRIu64 " per stream", indent6, + channel->attr.tracefile_count == 0 ? + 1 : channel->attr.tracefile_count); + if (channel->attr.tracefile_size != 0 ) { + MSG("%sTrace file size: %" PRIu64 " bytes", indent6, + channel->attr.tracefile_size); + } else { + MSG("%sTrace file size: %s", indent6, "unlimited"); + } switch (channel->attr.output) { case LTTNG_EVENT_SPLICE: - MSG("%soutput: splice()", indent6); + MSG("%sOutput mode: splice", indent6); break; case LTTNG_EVENT_MMAP: - MSG("%soutput: mmap()", indent6); + MSG("%sOutput mode: mmap", indent6); break; } + + MSG("\n%sStatistics:", indent4); + if (the_listed_session.snapshot_mode) { + /* + * The lost packet count is omitted for sessions in snapshot + * mode as it is misleading: it would indicate the number of + * packets that the consumer could not extract during the + * course of recording the snapshot. It does not have the + * same meaning as the "regular" lost packet count that + * would result from the consumer not keeping up with + * event production in an overwrite-mode channel. + * + * A more interesting statistic would be the number of + * packets lost between the first and last extracted + * packets of a given snapshot (which prevents most analyses). + */ + MSG("%sNone", indent6); + goto skip_stats_printing; + } + + if (!channel->attr.overwrite) { + MSG("%sDiscarded events: %" PRIu64, indent6, discarded_events); + } else { + MSG("%sLost packets: %" PRIu64, indent6, lost_packets); + } +skip_stats_printing: + return; } /* @@ -1241,7 +1393,7 @@ static int mi_list_channels(struct lttng_channel *channels, int count, unsigned int chan_found = 0; /* Open channels element */ - ret = mi_lttng_channels_open(writer); + ret = mi_lttng_channels_open(the_writer); if (ret) { goto error; } @@ -1256,7 +1408,7 @@ static int mi_list_channels(struct lttng_channel *channels, int count, } /* Write channel element and leave it open */ - ret = mi_lttng_channel(writer, &channels[i], 1); + ret = mi_lttng_channel(the_writer, &channels[i], 1); if (ret) { goto error; } @@ -1268,7 +1420,7 @@ static int mi_list_channels(struct lttng_channel *channels, int count, } /* Closing the channel element we opened earlier */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto error; } @@ -1279,7 +1431,7 @@ static int mi_list_channels(struct lttng_channel *channels, int count, } /* Close channels element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto error; } @@ -1301,7 +1453,7 @@ static int list_channels(const char *channel_name) DBG("Listing channel(s) (%s)", channel_name ? : ""); - count = lttng_list_channels(handle, &channels); + count = lttng_list_channels(the_handle, &channels); if (count < 0) { switch (-count) { case LTTNG_ERR_KERN_CHAN_NOT_FOUND: @@ -1311,7 +1463,6 @@ static int list_channels(const char *channel_name) count = 0; } else { ret = CMD_SUCCESS; - WARN("No kernel channel"); goto error_channels; } break; @@ -1371,88 +1522,355 @@ error_channels: return ret; } +static const char *get_capitalized_process_attr_str(enum lttng_process_attr process_attr) +{ + switch (process_attr) { + case LTTNG_PROCESS_ATTR_PROCESS_ID: + return "Process ID"; + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + return "Virtual process ID"; + case LTTNG_PROCESS_ATTR_USER_ID: + return "User ID"; + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + return "Virtual user ID"; + case LTTNG_PROCESS_ATTR_GROUP_ID: + return "Group ID"; + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + return "Virtual group ID"; + default: + return "Unknown"; + } + return NULL; +} + +static int handle_process_attr_status(enum lttng_process_attr process_attr, + enum lttng_process_attr_tracker_handle_status status) +{ + int ret = CMD_SUCCESS; + + switch (status) { + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY: + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK: + /* Carry on. */ + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR: + ERR("Communication occurred while fetching %s tracker", + lttng_process_attr_to_string(process_attr)); + ret = CMD_ERROR; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST: + ERR("Failed to get the inclusion set of the %s tracker: session `%s` no longer exists", + lttng_process_attr_to_string(process_attr), + the_handle->session_name); + ret = CMD_ERROR; + break; + default: + ERR("Unknown error occurred while fetching the inclusion set of the %s tracker", + lttng_process_attr_to_string(process_attr)); + ret = CMD_ERROR; + break; + } + + return ret; +} + +static int mi_output_empty_tracker(enum lttng_process_attr process_attr) +{ + int ret; + + ret = mi_lttng_process_attribute_tracker_open(the_writer, process_attr); + if (ret) { + goto end; + } + + ret = mi_lttng_close_multi_element(the_writer, 2); +end: + return ret; +} + +static inline bool is_value_type_name( + enum lttng_process_attr_value_type value_type) +{ + return value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME || + value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME; +} + /* - * List tracker PID(s) of session and domain. + * List a process attribute tracker for a session and domain tuple. */ -static int list_tracker_pids(void) +static int list_process_attr_tracker(enum lttng_process_attr process_attr) { int ret = 0; - int enabled; - int *pids = NULL; - size_t nr_pids; + unsigned int count, i; + enum lttng_tracking_policy policy; + enum lttng_error_code ret_code; + enum lttng_process_attr_tracker_handle_status handle_status; + enum lttng_process_attr_values_status values_status; + const struct lttng_process_attr_values *values; + struct lttng_process_attr_tracker_handle *tracker_handle = NULL; + + ret_code = lttng_session_get_tracker_handle(the_handle->session_name, + the_handle->domain.type, process_attr, &tracker_handle); + if (ret_code != LTTNG_OK) { + ERR("Failed to get process attribute tracker handle: %s", + lttng_strerror(ret_code)); + ret = CMD_ERROR; + goto end; + } - ret = lttng_list_tracker_pids(handle, - &enabled, &pids, &nr_pids); - if (ret) { - return ret; + handle_status = lttng_process_attr_tracker_handle_get_inclusion_set( + tracker_handle, &values); + ret = handle_process_attr_status(process_attr, handle_status); + if (ret != CMD_SUCCESS) { + goto end; } - if (enabled) { - int i; - _MSG("PID tracker: ["); - /* Mi tracker_pid element*/ - if (writer) { - /* Open tracker_pid and targets elements */ - ret = mi_lttng_pid_tracker_open(writer); - if (ret) { - goto end; - } + handle_status = lttng_process_attr_tracker_handle_get_tracking_policy( + tracker_handle, &policy); + ret = handle_process_attr_status(process_attr, handle_status); + if (ret != CMD_SUCCESS) { + goto end; + } + + { + char *process_attr_name; + const int print_ret = asprintf(&process_attr_name, "%ss:", + get_capitalized_process_attr_str(process_attr)); + + if (print_ret == -1) { + ret = CMD_FATAL; + goto end; } + _MSG(" %-22s", process_attr_name); + free(process_attr_name); + } + switch (policy) { + case LTTNG_TRACKING_POLICY_INCLUDE_SET: + break; + case LTTNG_TRACKING_POLICY_EXCLUDE_ALL: + if (the_writer) { + mi_output_empty_tracker(process_attr); + } + MSG("none"); + ret = CMD_SUCCESS; + goto end; + case LTTNG_TRACKING_POLICY_INCLUDE_ALL: + MSG("all"); + ret = CMD_SUCCESS; + goto end; + default: + ERR("Unknown tracking policy encoutered while listing the %s process attribute tracker of session `%s`", + lttng_process_attr_to_string(process_attr), + the_handle->session_name); + ret = CMD_FATAL; + goto end; + } - for (i = 0; i < nr_pids; i++) { - if (i) { - _MSG(","); - } - _MSG(" %d", pids[i]); + values_status = lttng_process_attr_values_get_count(values, &count); + if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) { + ERR("Failed to get the count of values in the inclusion set of the %s process attribute tracker of session `%s`", + lttng_process_attr_to_string(process_attr), + the_handle->session_name); + ret = CMD_FATAL; + goto end; + } - /* Mi */ - if (writer) { - ret = mi_lttng_pid_target(writer, pids[i], 0); - if (ret) { - goto end; - } - } + if (count == 0) { + /* Functionally equivalent to the 'exclude all' policy. */ + if (the_writer) { + mi_output_empty_tracker(process_attr); } - _MSG(" ]\n\n"); + MSG("none"); + ret = CMD_SUCCESS; + goto end; + } - /* Mi close tracker_pid and targets */ - if (writer) { - ret = mi_lttng_close_multi_element(writer,2); + /* Mi tracker_id element */ + if (the_writer) { + /* Open tracker_id and targets elements */ + ret = mi_lttng_process_attribute_tracker_open( + the_writer, process_attr); + if (ret) { + goto end; + } + } + + for (i = 0; i < count; i++) { + const enum lttng_process_attr_value_type value_type = + lttng_process_attr_values_get_type_at_index( + values, i); + int64_t integral_value = INT64_MAX; + const char *name = "error"; + + if (i >= 1) { + _MSG(", "); + } + switch (value_type) { + case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID: + { + pid_t pid; + + values_status = lttng_process_attr_values_get_pid_at_index( + values, i, &pid); + integral_value = (int64_t) pid; + break; + } + case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID: + { + uid_t uid; + + values_status = lttng_process_attr_values_get_uid_at_index( + values, i, &uid); + integral_value = (int64_t) uid; + break; + } + case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID: + { + gid_t gid; + + values_status = lttng_process_attr_values_get_gid_at_index( + values, i, &gid); + integral_value = (int64_t) gid; + break; + } + case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME: + values_status = lttng_process_attr_values_get_user_name_at_index( + values, i, &name); + break; + case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME: + values_status = lttng_process_attr_values_get_group_name_at_index( + values, i, &name); + break; + default: + ret = CMD_ERROR; + goto end; + } + + if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) { + /* + * Not possible given the current liblttng-ctl + * implementation. + */ + ERR("Unknown error occurred while fetching process attribute value in inclusion list"); + ret = CMD_FATAL; + goto end; + } + + if (is_value_type_name(value_type)) { + _MSG("`%s`", name); + } else { + _MSG("%" PRIi64, integral_value); + } + + /* Mi */ + if (the_writer) { + ret = is_value_type_name(value_type) ? + mi_lttng_string_process_attribute_value( + the_writer, + process_attr, name, + false) : + mi_lttng_integral_process_attribute_value( + the_writer, + process_attr, + integral_value, false); if (ret) { goto end; } } } + MSG(""); + + /* Mi close tracker_id and targets */ + if (the_writer) { + ret = mi_lttng_close_multi_element(the_writer, 2); + if (ret) { + goto end; + } + } end: - free(pids); + lttng_process_attr_tracker_handle_destroy(tracker_handle); return ret; - } /* - * List all tracker of a domain + * List all trackers of a domain */ -static int list_trackers(void) +static int list_trackers(const struct lttng_domain *domain) { - int ret; + int ret = 0; + MSG("Tracked process attributes"); /* Trackers listing */ if (lttng_opt_mi) { - ret = mi_lttng_trackers_open(writer); + ret = mi_lttng_trackers_open(the_writer); if (ret) { goto end; } } - /* pid tracker */ - ret = list_tracker_pids(); - if (ret) { - goto end; + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + /* pid tracker */ + ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_PROCESS_ID); + if (ret) { + goto end; + } + /* vpid tracker */ + ret = list_process_attr_tracker( + LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID); + if (ret) { + goto end; + } + /* uid tracker */ + ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_USER_ID); + if (ret) { + goto end; + } + /* vuid tracker */ + ret = list_process_attr_tracker( + LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID); + if (ret) { + goto end; + } + /* gid tracker */ + ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_GROUP_ID); + if (ret) { + goto end; + } + /* vgid tracker */ + ret = list_process_attr_tracker( + LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID); + if (ret) { + goto end; + } + break; + case LTTNG_DOMAIN_UST: + /* vpid tracker */ + ret = list_process_attr_tracker( + LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID); + if (ret) { + goto end; + } + /* vuid tracker */ + ret = list_process_attr_tracker( + LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID); + if (ret) { + goto end; + } + /* vgid tracker */ + ret = list_process_attr_tracker( + LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID); + if (ret) { + goto end; + } + break; + default: + break; } - + MSG(); if (lttng_opt_mi) { /* Close trackers element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto end; } @@ -1462,6 +1880,147 @@ end: return ret; } +static enum cmd_error_code print_periodic_rotation_schedule( + const struct lttng_rotation_schedule *schedule) +{ + enum cmd_error_code ret; + enum lttng_rotation_status status; + uint64_t value; + + status = lttng_rotation_schedule_periodic_get_period(schedule, + &value); + if (status != LTTNG_ROTATION_STATUS_OK) { + ERR("Failed to retrieve period parameter from periodic rotation schedule."); + ret = CMD_ERROR; + goto end; + } + + MSG(" timer period: %" PRIu64" %s", value, USEC_UNIT); + ret = CMD_SUCCESS; +end: + return ret; +} + +static enum cmd_error_code print_size_threshold_rotation_schedule( + const struct lttng_rotation_schedule *schedule) +{ + enum cmd_error_code ret; + enum lttng_rotation_status status; + uint64_t value; + + status = lttng_rotation_schedule_size_threshold_get_threshold(schedule, + &value); + if (status != LTTNG_ROTATION_STATUS_OK) { + ERR("Failed to retrieve size parameter from size-based rotation schedule."); + ret = CMD_ERROR; + goto end; + } + + MSG(" size threshold: %" PRIu64" bytes", value); + ret = CMD_SUCCESS; +end: + return ret; +} + +static enum cmd_error_code print_rotation_schedule( + const struct lttng_rotation_schedule *schedule) +{ + enum cmd_error_code ret; + + switch (lttng_rotation_schedule_get_type(schedule)) { + case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: + ret = print_size_threshold_rotation_schedule(schedule); + break; + case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: + ret = print_periodic_rotation_schedule(schedule); + break; + default: + ret = CMD_ERROR; + } + return ret; +} + +/* + * List the automatic rotation settings. + */ +static enum cmd_error_code list_rotate_settings(const char *session_name) +{ + int ret; + enum cmd_error_code cmd_ret = CMD_SUCCESS; + unsigned int count, i; + struct lttng_rotation_schedules *schedules = NULL; + enum lttng_rotation_status status; + + ret = lttng_session_list_rotation_schedules(session_name, &schedules); + if (ret != LTTNG_OK) { + ERR("Failed to list session rotation schedules: %s", lttng_strerror(ret)); + cmd_ret = CMD_ERROR; + goto end; + } + + status = lttng_rotation_schedules_get_count(schedules, &count); + if (status != LTTNG_ROTATION_STATUS_OK) { + ERR("Failed to retrieve the number of session rotation schedules."); + cmd_ret = CMD_ERROR; + goto end; + } + + if (count == 0) { + cmd_ret = CMD_SUCCESS; + goto end; + } + + MSG("Automatic rotation schedules:"); + if (lttng_opt_mi) { + ret = mi_lttng_writer_open_element(the_writer, + mi_lttng_element_rotation_schedules); + if (ret) { + cmd_ret = CMD_ERROR; + goto end; + } + } + + for (i = 0; i < count; i++) { + enum cmd_error_code tmp_ret = CMD_SUCCESS; + const struct lttng_rotation_schedule *schedule; + + schedule = lttng_rotation_schedules_get_at_index(schedules, i); + if (!schedule) { + ERR("Failed to retrieve session rotation schedule."); + cmd_ret = CMD_ERROR; + goto end; + } + + if (lttng_opt_mi) { + ret = mi_lttng_rotation_schedule(the_writer, schedule); + if (ret) { + tmp_ret = CMD_ERROR; + } + } else { + tmp_ret = print_rotation_schedule(schedule); + } + + /* + * Report an error if the serialization of any of the + * descriptors failed. + */ + cmd_ret = cmd_ret ? cmd_ret : tmp_ret; + } + + _MSG("\n"); + if (lttng_opt_mi) { + /* Close the rotation_schedules element. */ + ret = mi_lttng_writer_close_element(the_writer); + if (ret) { + cmd_ret = CMD_ERROR; + goto end; + } + } +end: + lttng_rotation_schedules_destroy(schedules); + return cmd_ret; +} + /* * Machine interface * Find the session with session_name as name @@ -1483,7 +2042,7 @@ static int mi_list_session(const char *session_name, /* We need to leave it open to append other informations * like domain, channel, events etc.*/ session_found = 1; - ret = mi_lttng_session(writer, &sessions[i], 1); + ret = mi_lttng_session(the_writer, &sessions[i], 1); if (ret) { goto end; } @@ -1510,21 +2069,21 @@ static int mi_list_sessions(struct lttng_session *sessions, int count) int ret, i; /* Opening sessions element */ - ret = mi_lttng_sessions_open(writer); + ret = mi_lttng_sessions_open(the_writer); if (ret) { goto end; } /* Listing sessions */ for (i = 0; i < count; i++) { - ret = mi_lttng_session(writer, &sessions[i], 0); + ret = mi_lttng_session(the_writer, &sessions[i], 0); if (ret) { goto end; } } /* Closing sessions element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto end; } @@ -1543,7 +2102,7 @@ static int list_sessions(const char *session_name) int ret = CMD_SUCCESS; int count, i; unsigned int session_found = 0; - struct lttng_session *sessions; + struct lttng_session *sessions = NULL; count = lttng_list_sessions(&sessions); DBG("Session count %d", count); @@ -1556,7 +2115,7 @@ static int list_sessions(const char *session_name) if (lttng_opt_mi) { /* Mi */ if (session_name == NULL) { - /* List all session */ + /* List all sessions */ ret = mi_list_sessions(sessions, count); } else { /* Note : this return an open session element */ @@ -1564,7 +2123,7 @@ static int list_sessions(const char *session_name) } if (ret) { ret = CMD_ERROR; - goto error; + goto end; } } else { /* Pretty print */ @@ -1577,7 +2136,6 @@ static int list_sessions(const char *session_name) MSG("Available tracing sessions:"); } - for (i = 0; i < count; i++) { if (session_name != NULL) { if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { @@ -1585,18 +2143,26 @@ static int list_sessions(const char *session_name) MSG("Tracing session %s: [%s%s]", session_name, active_string(sessions[i].enabled), snapshot_string(sessions[i].snapshot_mode)); - MSG("%sTrace path: %s\n", indent4, sessions[i].path); + if (*sessions[i].path) { + MSG("%sTrace output: %s\n", indent4, sessions[i].path); + } + memcpy(&the_listed_session, + &sessions[i], + sizeof(the_listed_session)); break; } } else { - MSG(" %d) %s (%s) [%s%s]", i + 1, - sessions[i].name, sessions[i].path, + MSG(" %d) %s [%s%s]", i + 1, + sessions[i].name, active_string(sessions[i].enabled), snapshot_string(sessions[i].snapshot_mode)); - MSG("%sTrace path: %s", indent4, sessions[i].path); + if (*sessions[i].path) { + MSG("%sTrace output: %s", indent4, sessions[i].path); + } if (sessions[i].live_timer_interval != 0) { - MSG("%sLive timer interval (usec): %u", indent4, - sessions[i].live_timer_interval); + MSG("%sLive timer interval: %u %s", indent4, + sessions[i].live_timer_interval, + USEC_UNIT); } MSG(""); } @@ -1605,7 +2171,7 @@ static int list_sessions(const char *session_name) if (!session_found && session_name != NULL) { ERR("Session '%s' not found", session_name); ret = CMD_ERROR; - goto error; + goto end; } if (session_name == NULL) { @@ -1613,9 +2179,8 @@ static int list_sessions(const char *session_name) } } -error: - free(sessions); end: + free(sessions); return ret; } @@ -1628,20 +2193,20 @@ static int mi_list_domains(struct lttng_domain *domains, int count) { int i, ret; /* Open domains element */ - ret = mi_lttng_domains_open(writer); + ret = mi_lttng_domains_open(the_writer); if (ret) { goto end; } for (i = 0; i < count; i++) { - ret = mi_lttng_domain(writer, &domains[i] , 0); + ret = mi_lttng_domain(the_writer, &domains[i], 0); if (ret) { goto end; } } /* Closing domains element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { goto end; } @@ -1716,7 +2281,7 @@ end: int cmd_list(int argc, const char **argv) { int opt, ret = CMD_SUCCESS; - const char *session_name; + const char *session_name, *leftover = NULL; static poptContext pc; struct lttng_domain domain; struct lttng_domain *domains = NULL; @@ -1724,7 +2289,6 @@ int cmd_list(int argc, const char **argv) memset(&domain, 0, sizeof(domain)); if (argc < 1) { - usage(stderr); ret = CMD_ERROR; goto end; } @@ -1735,7 +2299,7 @@ int cmd_list(int argc, const char **argv) while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case OPT_HELP: - usage(stdout); + SHOW_HELP(); goto end; case OPT_USERSPACE: opt_userspace = 1; @@ -1744,7 +2308,6 @@ int cmd_list(int argc, const char **argv) list_cmd_options(stdout, long_options); goto end; default: - usage(stderr); ret = CMD_UNDEFINED; goto end; } @@ -1752,23 +2315,24 @@ int cmd_list(int argc, const char **argv) /* Mi check */ if (lttng_opt_mi) { - writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi); - if (!writer) { + the_writer = mi_lttng_writer_create( + fileno(stdout), lttng_opt_mi); + if (!the_writer) { ret = CMD_ERROR; goto end; } /* Open command element */ - ret = mi_lttng_writer_command_open(writer, - mi_lttng_element_command_list); + ret = mi_lttng_writer_command_open( + the_writer, mi_lttng_element_command_list); if (ret) { ret = CMD_ERROR; goto end; } /* Open output element */ - ret = mi_lttng_writer_open_element(writer, - mi_lttng_element_command_output); + ret = mi_lttng_writer_open_element( + the_writer, mi_lttng_element_command_output); if (ret) { ret = CMD_ERROR; goto end; @@ -1779,6 +2343,13 @@ int cmd_list(int argc, const char **argv) session_name = poptGetArg(pc); DBG2("Session name: %s", session_name); + leftover = poptGetArg(pc); + if (leftover) { + ERR("Unknown argument: %s", leftover); + ret = CMD_ERROR; + goto end; + } + if (opt_kernel) { domain.type = LTTNG_DOMAIN_KERNEL; } else if (opt_userspace) { @@ -1800,8 +2371,8 @@ int cmd_list(int argc, const char **argv) } if (opt_kernel || opt_userspace || opt_jul || opt_log4j || opt_python) { - handle = lttng_create_handle(session_name, &domain); - if (handle == NULL) { + the_handle = lttng_create_handle(session_name, &domain); + if (the_handle == NULL) { ret = CMD_FATAL; goto end; } @@ -1849,7 +2420,7 @@ int cmd_list(int argc, const char **argv) if (lttng_opt_mi) { /* Open element sessions * Present for xml consistency */ - ret = mi_lttng_sessions_open(writer); + ret = mi_lttng_sessions_open(the_writer); if (ret) { goto end; } @@ -1860,6 +2431,11 @@ int cmd_list(int argc, const char **argv) goto end; } + ret = list_rotate_settings(session_name); + if (ret) { + goto end; + } + /* Domain listing */ if (opt_domain) { ret = list_domains(session_name); @@ -1872,14 +2448,14 @@ int cmd_list(int argc, const char **argv) /* Add of domains and domain element for xml * consistency and validation */ - ret = mi_lttng_domains_open(writer); + ret = mi_lttng_domains_open(the_writer); if (ret) { goto end; } /* Open domain and leave it open for * nested channels printing */ - ret = mi_lttng_domain(writer, &domain, 1); + ret = mi_lttng_domain(the_writer, &domain, 1); if (ret) { goto end; } @@ -1888,7 +2464,7 @@ int cmd_list(int argc, const char **argv) /* Trackers */ - ret = list_trackers(); + ret = list_trackers(&domain); if (ret) { goto end; } @@ -1901,7 +2477,8 @@ int cmd_list(int argc, const char **argv) if (lttng_opt_mi) { /* Close domain and domain element */ - ret = mi_lttng_close_multi_element(writer, 2); + ret = mi_lttng_close_multi_element( + the_writer, 2); } if (ret) { goto end; @@ -1920,7 +2497,7 @@ int cmd_list(int argc, const char **argv) } if (lttng_opt_mi) { - ret = mi_lttng_domains_open(writer); + ret = mi_lttng_domains_open(the_writer); if (ret) { ret = CMD_ERROR; goto end; @@ -1930,22 +2507,22 @@ int cmd_list(int argc, const char **argv) for (i = 0; i < nb_domain; i++) { switch (domains[i].type) { case LTTNG_DOMAIN_KERNEL: - MSG("=== Domain: Kernel ===\n"); + MSG("=== Domain: Linux kernel ===\n"); break; case LTTNG_DOMAIN_UST: - MSG("=== Domain: UST global ===\n"); - MSG("Buffer type: %s\n", + MSG("=== Domain: User space ===\n"); + MSG("Buffering scheme: %s\n", domains[i].buf_type == - LTTNG_BUFFER_PER_PID ? "per PID" : "per UID"); + LTTNG_BUFFER_PER_PID ? "per-process" : "per-user"); break; case LTTNG_DOMAIN_JUL: - MSG("=== Domain: JUL (Java Util Logging) ===\n"); + MSG("=== Domain: java.util.logging (JUL) ===\n"); break; case LTTNG_DOMAIN_LOG4J: - MSG("=== Domain: LOG4j (Logging for Java) ===\n"); + MSG("=== Domain: log4j ===\n"); break; case LTTNG_DOMAIN_PYTHON: - MSG("=== Domain: Python (logging) ===\n"); + MSG("=== Domain: Python logging ===\n"); break; default: MSG("=== Domain: Unimplemented ===\n"); @@ -1953,7 +2530,8 @@ int cmd_list(int argc, const char **argv) } if (lttng_opt_mi) { - ret = mi_lttng_domain(writer, &domains[i], 1); + ret = mi_lttng_domain(the_writer, + &domains[i], 1); if (ret) { ret = CMD_ERROR; goto end; @@ -1961,12 +2539,13 @@ int cmd_list(int argc, const char **argv) } /* Clean handle before creating a new one */ - if (handle) { - lttng_destroy_handle(handle); + if (the_handle) { + lttng_destroy_handle(the_handle); } - handle = lttng_create_handle(session_name, &domains[i]); - if (handle == NULL) { + the_handle = lttng_create_handle( + session_name, &domains[i]); + if (the_handle == NULL) { ret = CMD_FATAL; goto end; } @@ -1985,7 +2564,7 @@ int cmd_list(int argc, const char **argv) switch (domains[i].type) { case LTTNG_DOMAIN_KERNEL: case LTTNG_DOMAIN_UST: - ret = list_trackers(); + ret = list_trackers(&domains[i]); if (ret) { goto end; } @@ -2002,7 +2581,8 @@ int cmd_list(int argc, const char **argv) next_domain: if (lttng_opt_mi) { /* Close domain element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element( + the_writer); if (ret) { ret = CMD_ERROR; goto end; @@ -2012,7 +2592,8 @@ next_domain: } if (lttng_opt_mi) { /* Close the domains, session and sessions element */ - ret = mi_lttng_close_multi_element(writer, 3); + ret = mi_lttng_close_multi_element( + the_writer, 3); if (ret) { ret = CMD_ERROR; goto end; @@ -2024,14 +2605,14 @@ next_domain: /* Mi closing */ if (lttng_opt_mi) { /* Close output element */ - ret = mi_lttng_writer_close_element(writer); + ret = mi_lttng_writer_close_element(the_writer); if (ret) { ret = CMD_ERROR; goto end; } /* Command element close */ - ret = mi_lttng_writer_command_close(writer); + ret = mi_lttng_writer_command_close(the_writer); if (ret) { ret = CMD_ERROR; goto end; @@ -2039,14 +2620,14 @@ next_domain: } end: /* Mi clean-up */ - if (writer && mi_lttng_writer_destroy(writer)) { + if (the_writer && mi_lttng_writer_destroy(the_writer)) { /* Preserve original error code */ ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL; } free(domains); - if (handle) { - lttng_destroy_handle(handle); + if (the_handle) { + lttng_destroy_handle(the_handle); } poptFreeContext(pc);