X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Flist.c;h=eabeb8132ecd36c6e15fb996cb8bdba96b61249d;hp=50d6114c3d166be10483b71974b6418cf6152494;hb=87597c2c3bbaa1502ad2025cbf16704829f3b464;hpb=d14d33bf091e72b23b1f90ea18a0a01bed098b76 diff --git a/src/bin/lttng/commands/list.c b/src/bin/lttng/commands/list.c index 50d6114c3..eabeb8132 100644 --- a/src/bin/lttng/commands/list.c +++ b/src/bin/lttng/commands/list.c @@ -15,7 +15,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -23,22 +23,31 @@ #include #include +#include +#include + #include "../command.h" static int opt_userspace; static int opt_kernel; +static int opt_jul; +static int opt_log4j; +static int opt_python; static char *opt_channel; static int opt_domain; -#if 0 -/* Not implemented yet */ -static char *opt_cmd_name; -static pid_t opt_pid; -#endif +static int opt_fields; +static int opt_syscall; 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, @@ -46,50 +55,27 @@ enum { }; static struct lttng_handle *handle; +static struct mi_writer *writer; + +/* Only set when listing a single session. */ +static struct lttng_session listed_session; static struct poptOption long_options[] = { /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */ - {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0}, - {"kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, 0, 0}, -#if 0 - /* Not implemented yet */ - {"userspace", 'u', POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, &opt_cmd_name, OPT_USERSPACE, 0, 0}, - {"pid", 'p', POPT_ARG_INT, &opt_pid, 0, 0, 0}, -#else - {"userspace", 'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0}, -#endif - {"channel", 'c', POPT_ARG_STRING, &opt_channel, 0, 0, 0}, - {"domain", 'd', POPT_ARG_VAL, &opt_domain, 1, 0, 0}, + {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0}, + {"kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, 0, 0}, + {"jul", 'j', POPT_ARG_VAL, &opt_jul, 1, 0, 0}, + {"log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, 0, 0}, + {"python", 'p', POPT_ARG_VAL, &opt_python, 1, 0, 0}, + {"userspace", 'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0}, + {"channel", 'c', POPT_ARG_STRING, &opt_channel, 0, 0, 0}, + {"domain", 'd', POPT_ARG_VAL, &opt_domain, 1, 0, 0}, + {"fields", 'f', POPT_ARG_VAL, &opt_fields, 1, 0, 0}, + {"syscall", 'S', POPT_ARG_VAL, &opt_syscall, 1, 0, 0}, {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL}, {0, 0, 0, 0, 0, 0, 0} }; -/* - * usage - */ -static void usage(FILE *ofp) -{ - fprintf(ofp, "usage: lttng list [OPTIONS] [SESSION []]\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"); -#if 0 - fprintf(ofp, " -p, --pid PID List user-space events by PID\n"); -#endif - 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. * @@ -99,9 +85,10 @@ static void usage(FILE *ofp) static char *get_cmdline_by_pid(pid_t pid) { int ret; - FILE *fp; + FILE *fp = NULL; char *cmdline = NULL; - char path[24]; /* Can't go bigger than /proc/65535/cmdline */ + /* Can't go bigger than /proc/LTTNG_MAX_PID/cmdline */ + char path[sizeof("/proc//cmdline") + sizeof(LTTNG_MAX_PID_STR) - 1]; snprintf(path, sizeof(path), "/proc/%d/cmdline", pid); fp = fopen(path, "r"); @@ -110,14 +97,20 @@ static char *get_cmdline_by_pid(pid_t pid) } /* Caller must free() *cmdline */ - cmdline = malloc(PATH_MAX); + cmdline = zmalloc(PATH_MAX); + if (!cmdline) { + PERROR("malloc cmdline"); + goto end; + } ret = fread(cmdline, 1, PATH_MAX, fp); if (ret < 0) { - perror("fread proc list"); + PERROR("fread proc list"); } - fclose(fp); end: + if (fp) { + fclose(fp); + } return cmdline; } @@ -125,13 +118,23 @@ static const char *active_string(int value) { switch (value) { - case 0: return " [inactive]"; - case 1: return " [active]"; + case 0: return "inactive"; + case 1: return "active"; case -1: return ""; default: return NULL; } } +static const char *snapshot_string(int value) +{ + switch (value) { + case 1: + return " snapshot"; + default: + return ""; + } +} + static const char *enabled_string(int value) { @@ -143,43 +146,182 @@ const char *enabled_string(int value) } } -static const char *loglevel_string(int value) +static +const char *safe_string(const char *str) +{ + return str ? str : ""; +} + +static const char *logleveltype_string(enum lttng_loglevel_type value) { switch (value) { - case -1: + case LTTNG_EVENT_LOGLEVEL_ALL: + return ":"; + case LTTNG_EVENT_LOGLEVEL_RANGE: + return " <="; + case LTTNG_EVENT_LOGLEVEL_SINGLE: + return " =="; + default: + return " <>"; + } +} + +static const char *bitness_event(enum lttng_event_flag flags) +{ + if (flags & LTTNG_EVENT_FLAG_SYSCALL_32) { + if (flags & LTTNG_EVENT_FLAG_SYSCALL_64) { + return " [32/64-bit]"; + } else { + return " [32-bit]"; + } + } else if (flags & LTTNG_EVENT_FLAG_SYSCALL_64) { + return " [64-bit]"; + } else { return ""; - case LTTNG_LOGLEVEL_EMERG: - return "TRACE_EMERG"; - case LTTNG_LOGLEVEL_ALERT: - return "TRACE_ALERT"; - case LTTNG_LOGLEVEL_CRIT: - return "TRACE_CRIT"; - case LTTNG_LOGLEVEL_ERR: - return "TRACE_ERR"; - case LTTNG_LOGLEVEL_WARNING: - return "TRACE_WARNING"; - case LTTNG_LOGLEVEL_NOTICE: - return "TRACE_NOTICE"; - case LTTNG_LOGLEVEL_INFO: - return "TRACE_INFO"; - case LTTNG_LOGLEVEL_DEBUG_SYSTEM: - return "TRACE_DEBUG_SYSTEM"; - case LTTNG_LOGLEVEL_DEBUG_PROGRAM: - return "TRACE_DEBUG_PROGRAM"; - case LTTNG_LOGLEVEL_DEBUG_PROCESS: - return "TRACE_DEBUG_PROCESS"; - case LTTNG_LOGLEVEL_DEBUG_MODULE: - return "TRACE_DEBUG_MODULE"; - case LTTNG_LOGLEVEL_DEBUG_UNIT: - return "TRACE_DEBUG_UNIT"; - case LTTNG_LOGLEVEL_DEBUG_FUNCTION: - return "TRACE_DEBUG_FUNCTION"; - case LTTNG_LOGLEVEL_DEBUG_LINE: - return "TRACE_DEBUG_LINE"; - case LTTNG_LOGLEVEL_DEBUG: - return "TRACE_DEBUG"; + } +} + +/* + * Get exclusion names message for a single event. + * + * Returned pointer must be freed by caller. Returns NULL on error. + */ +static char *get_exclusion_names_msg(struct lttng_event *event) +{ + int ret; + int exclusion_count; + char *exclusion_msg = NULL; + char *at; + size_t i; + const char * const exclusion_fmt = " [exclusions: "; + const size_t exclusion_fmt_len = strlen(exclusion_fmt); + + exclusion_count = lttng_event_get_exclusion_name_count(event); + if (exclusion_count < 0) { + goto end; + } else if (exclusion_count == 0) { + /* + * No exclusions: return copy of empty string so that + * it can be freed by caller. + */ + exclusion_msg = strdup(""); + goto end; + } + + /* + * exclusion_msg's size is bounded by the exclusion_fmt string, + * a comma per entry, the entry count (fixed-size), a closing + * bracket, and a trailing \0. + */ + exclusion_msg = malloc(exclusion_count + + exclusion_count * LTTNG_SYMBOL_NAME_LEN + + exclusion_fmt_len + 1); + if (!exclusion_msg) { + goto end; + } + + at = strcpy(exclusion_msg, exclusion_fmt) + exclusion_fmt_len; + for (i = 0; i < exclusion_count; ++i) { + const char *name; + + /* Append comma between exclusion names */ + if (i > 0) { + *at = ','; + at++; + } + + ret = lttng_event_get_exclusion_name(event, i, &name); + if (ret) { + /* Prints '?' on local error; should never happen */ + *at = '?'; + at++; + continue; + } + + /* Append exclusion name */ + at += sprintf(at, "%s", name); + } + + /* This also puts a final '\0' at the end of exclusion_msg */ + strcpy(at, "]"); + +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; + 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: - return "<>"; + ERR("Invalid probe type encountered"); } } @@ -188,27 +330,69 @@ static const char *loglevel_string(int value) */ static void print_events(struct lttng_event *event) { + int ret; + const char *filter_str; + char *filter_msg = NULL; + char *exclusion_msg = NULL; + + ret = lttng_event_get_filter_expression(event, &filter_str); + + if (ret) { + filter_msg = strdup(" [failed to retrieve filter]"); + } else if (filter_str) { + const char * const filter_fmt = " [filter: '%s']"; + + filter_msg = malloc(strlen(filter_str) + + strlen(filter_fmt) + 1); + if (filter_msg) { + sprintf(filter_msg, filter_fmt, + filter_str); + } + } + + exclusion_msg = get_exclusion_names_msg(event); + if (!exclusion_msg) { + exclusion_msg = strdup(" [failed to retrieve exclusions]"); + } + switch (event->type) { case LTTNG_EVENT_TRACEPOINT: { if (event->loglevel != -1) { - MSG("%s%s (loglevel: %s (%d)) (type: tracepoint)%s", + MSG("%s%s (loglevel%s %s (%d)) (type: tracepoint)%s%s%s", indent6, event->name, - loglevel_string(event->loglevel), + logleveltype_string(event->loglevel_type), + mi_lttng_loglevel_string(event->loglevel, handle->domain.type), event->loglevel, - enabled_string(event->enabled)); + enabled_string(event->enabled), + safe_string(exclusion_msg), + safe_string(filter_msg)); } else { - MSG("%s%s (type: tracepoint)%s", + MSG("%s%s (type: tracepoint)%s%s%s", indent6, event->name, - enabled_string(event->enabled)); + enabled_string(event->enabled), + safe_string(exclusion_msg), + safe_string(filter_msg)); } break; } + case LTTNG_EVENT_FUNCTION: + MSG("%s%s (type: function)%s%s", indent6, + event->name, enabled_string(event->enabled), + safe_string(filter_msg)); + if (event->attr.probe.addr != 0) { + MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr); + } else { + MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset); + MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name); + } + break; case LTTNG_EVENT_PROBE: - MSG("%s%s (type: probe)%s", indent6, - event->name, enabled_string(event->enabled)); + MSG("%s%s (type: probe)%s%s", indent6, + event->name, enabled_string(event->enabled), + safe_string(filter_msg)); if (event->attr.probe.addr != 0) { MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr); } else { @@ -216,245 +400,1416 @@ static void print_events(struct lttng_event *event) MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name); } break; - case LTTNG_EVENT_FUNCTION: + case LTTNG_EVENT_USERSPACE_PROBE: + print_userspace_probe_location(event); + break; case LTTNG_EVENT_FUNCTION_ENTRY: - MSG("%s%s (type: function)%s", indent6, - event->name, enabled_string(event->enabled)); + MSG("%s%s (type: function)%s%s", indent6, + event->name, enabled_string(event->enabled), + safe_string(filter_msg)); MSG("%ssymbol: \"%s\"", indent8, event->attr.ftrace.symbol_name); break; case LTTNG_EVENT_SYSCALL: - MSG("%ssyscalls (type: syscall)%s", indent6, - enabled_string(event->enabled)); + MSG("%s%s%s%s%s%s", indent6, event->name, + (opt_syscall ? "" : " (type:syscall)"), + enabled_string(event->enabled), + bitness_event(event->flags), + safe_string(filter_msg)); break; case LTTNG_EVENT_NOOP: - MSG("%s (type: noop)%s", indent6, - enabled_string(event->enabled)); + MSG("%s (type: noop)%s%s", indent6, + enabled_string(event->enabled), + safe_string(filter_msg)); break; case LTTNG_EVENT_ALL: + /* Fall-through. */ + default: /* We should never have "all" events in list. */ assert(0); break; } + + free(filter_msg); + free(exclusion_msg); +} + +static const char *field_type(struct lttng_event_field *field) +{ + switch(field->type) { + case LTTNG_EVENT_FIELD_INTEGER: + return "integer"; + case LTTNG_EVENT_FIELD_ENUM: + return "enum"; + case LTTNG_EVENT_FIELD_FLOAT: + return "float"; + case LTTNG_EVENT_FIELD_STRING: + return "string"; + case LTTNG_EVENT_FIELD_OTHER: + default: /* fall-through */ + return "unknown"; + } } /* - * Ask session daemon for all user space tracepoints available. + * Pretty print single event fields. */ -static int list_ust_events(void) +static void print_event_field(struct lttng_event_field *field) +{ + if (!field->field_name[0]) { + return; + } + MSG("%sfield: %s (%s)%s", indent8, field->field_name, + field_type(field), field->nowrite ? " [no write]" : ""); +} + +/* + * Machine interface + * Jul and ust event listing + */ +static int mi_list_agent_ust_events(struct lttng_event *events, int count, + struct lttng_domain *domain) +{ + int ret, i; + pid_t cur_pid = 0; + char *cmdline = NULL; + int pid_element_open = 0; + + /* Open domains element */ + ret = mi_lttng_domains_open(writer); + if (ret) { + goto end; + } + + /* Write domain */ + ret = mi_lttng_domain(writer, domain, 1); + if (ret) { + goto end; + } + + /* Open pids element element */ + ret = mi_lttng_pids_open(writer); + if (ret) { + goto end; + } + + for (i = 0; i < count; i++) { + 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); + if (ret) { + goto end; + } + pid_element_open = 0; + } + + cur_pid = events[i].pid; + cmdline = get_cmdline_by_pid(cur_pid); + if (!cmdline) { + ret = CMD_ERROR; + goto end; + } + + if (!pid_element_open) { + /* Open and write a pid element */ + ret = mi_lttng_pid(writer, cur_pid, cmdline, 1); + if (ret) { + goto error; + } + + /* Open events element */ + ret = mi_lttng_events_open(writer); + if (ret) { + goto error; + } + + pid_element_open = 1; + } + free(cmdline); + } + + /* Write an event */ + ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + if (ret) { + goto end; + } + } + + /* Close pids */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto end; + } + + /* Close domain, domains */ + ret = mi_lttng_close_multi_element(writer, 2); +end: + return ret; +error: + free(cmdline); + return ret; +} + +static int list_agent_events(void) { - int i, size; + int i, size, ret = CMD_SUCCESS; struct lttng_domain domain; - struct lttng_handle *handle; - struct lttng_event *event_list; + struct lttng_handle *handle = NULL; + struct lttng_event *event_list = NULL; pid_t cur_pid = 0; + char *cmdline = NULL; + const char *agent_domain_str; memset(&domain, 0, sizeof(domain)); + if (opt_jul) { + domain.type = LTTNG_DOMAIN_JUL; + } else if (opt_log4j) { + domain.type = LTTNG_DOMAIN_LOG4J; + } else if (opt_python) { + domain.type = LTTNG_DOMAIN_PYTHON; + } else { + ERR("Invalid agent domain selected."); + ret = CMD_ERROR; + goto error; + } - DBG("Getting UST tracing events"); + agent_domain_str = get_domain_str(domain.type); - domain.type = LTTNG_DOMAIN_UST; + DBG("Getting %s tracing events", agent_domain_str); handle = lttng_create_handle(NULL, &domain); if (handle == NULL) { - goto error; + ret = CMD_ERROR; + goto end; } size = lttng_list_tracepoints(handle, &event_list); if (size < 0) { - ERR("Unable to list UST events"); - lttng_destroy_handle(handle); - return size; - } - - MSG("UST events:\n-------------"); - - if (size == 0) { - MSG("None"); + ERR("Unable to list %s events: %s", agent_domain_str, + lttng_strerror(size)); + ret = CMD_ERROR; + goto end; } - for (i = 0; i < size; i++) { - if (cur_pid != event_list[i].pid) { - cur_pid = event_list[i].pid; - MSG("\nPID: %d - Name: %s", cur_pid, get_cmdline_by_pid(cur_pid)); + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_agent_ust_events(event_list, size, &domain); + if (ret) { + ret = CMD_ERROR; + goto error; } - print_events(&event_list[i]); - } + } else { + /* Pretty print */ + MSG("%s events (Logger name):\n-------------------------", + agent_domain_str); - MSG(""); + if (size == 0) { + MSG("None"); + } - free(event_list); - lttng_destroy_handle(handle); + for (i = 0; i < size; i++) { + if (cur_pid != event_list[i].pid) { + cur_pid = event_list[i].pid; + cmdline = get_cmdline_by_pid(cur_pid); + if (cmdline == NULL) { + ret = CMD_ERROR; + goto error; + } + MSG("\nPID: %d - Name: %s", cur_pid, cmdline); + free(cmdline); + } + MSG("%s- %s", indent6, event_list[i].name); + } - return CMD_SUCCESS; + MSG(""); + } error: + free(event_list); +end: lttng_destroy_handle(handle); - return -1; + return ret; } /* - * Ask for all trace events in the kernel and pretty print them. + * Ask session daemon for all user space tracepoints available. */ -static int list_kernel_events(void) +static int list_ust_events(void) { - int i, size; + int i, size, ret = CMD_SUCCESS; struct lttng_domain domain; struct lttng_handle *handle; - struct lttng_event *event_list; + struct lttng_event *event_list = NULL; + pid_t cur_pid = 0; + char *cmdline = NULL; memset(&domain, 0, sizeof(domain)); - DBG("Getting kernel tracing events"); + DBG("Getting UST tracing events"); - domain.type = LTTNG_DOMAIN_KERNEL; + domain.type = LTTNG_DOMAIN_UST; handle = lttng_create_handle(NULL, &domain); if (handle == NULL) { - goto error; + ret = CMD_ERROR; + goto end; } size = lttng_list_tracepoints(handle, &event_list); if (size < 0) { - ERR("Unable to list kernel events"); - lttng_destroy_handle(handle); - return size; + ERR("Unable to list UST events: %s", lttng_strerror(size)); + ret = CMD_ERROR; + goto error; } - MSG("Kernel events:\n-------------"); + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_agent_ust_events(event_list, size, &domain); + } else { + /* Pretty print */ + MSG("UST events:\n-------------"); - for (i = 0; i < size; i++) { - print_events(&event_list[i]); - } + if (size == 0) { + MSG("None"); + } + + for (i = 0; i < size; i++) { + if (cur_pid != event_list[i].pid) { + cur_pid = event_list[i].pid; + cmdline = get_cmdline_by_pid(cur_pid); + if (cmdline == NULL) { + ret = CMD_ERROR; + goto error; + } + MSG("\nPID: %d - Name: %s", cur_pid, cmdline); + free(cmdline); + } + print_events(&event_list[i]); + } - MSG(""); + MSG(""); + } +error: free(event_list); +end: + lttng_destroy_handle(handle); + return ret; +} + +/* + * Machine interface + * List all ust event with their fields + */ +static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, + struct lttng_domain *domain) +{ + int ret, i; + pid_t cur_pid = 0; + char *cmdline = NULL; + int pid_element_open = 0; + 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); + if (ret) { + goto end; + } + + /* Write domain */ + ret = mi_lttng_domain(writer, domain, 1); + if (ret) { + goto end; + } + + /* Open pids element */ + ret = mi_lttng_pids_open(writer); + if (ret) { + goto end; + } + + for (i = 0; i < count; i++) { + 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); + if (ret) { + goto end; + } + event_element_open = 0; + } + /* Close the previous events, pid element */ + ret = mi_lttng_close_multi_element(writer, 2); + if (ret) { + goto end; + } + pid_element_open = 0; + } + + cur_pid = fields[i].event.pid; + 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); + if (ret) { + goto error; + } + + /* Open events element */ + ret = mi_lttng_events_open(writer); + if (ret) { + goto error; + } + pid_element_open = 1; + } + free(cmdline); + /* Wipe current event since we are about to print a new PID. */ + memset(&cur_event, 0, sizeof(cur_event)); + } + + 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); + if (ret) { + goto end; + } + event_element_open = 0; + } + + memcpy(&cur_event, &fields[i].event, + sizeof(cur_event)); + + if (!event_element_open) { + /* Open and write the event */ + ret = mi_lttng_event(writer, &cur_event, 1, + handle->domain.type); + if (ret) { + goto end; + } + + /* Open a fields element */ + ret = mi_lttng_event_fields_open(writer); + if (ret) { + goto end; + } + event_element_open = 1; + } + } + + /* Print the event_field */ + ret = mi_lttng_event_field(writer, &fields[i]); + if (ret) { + goto end; + } + } + + /* Close pid, domain, domains */ + ret = mi_lttng_close_multi_element(writer, 3); +end: + return ret; +error: + free(cmdline); + return ret; +} + +/* + * Ask session daemon for all user space tracepoint fields available. + */ +static int list_ust_event_fields(void) +{ + int i, size, ret = CMD_SUCCESS; + struct lttng_domain domain; + struct lttng_handle *handle; + struct lttng_event_field *event_field_list; + pid_t cur_pid = 0; + char *cmdline = NULL; + + struct lttng_event cur_event; + + memset(&domain, 0, sizeof(domain)); + memset(&cur_event, 0, sizeof(cur_event)); + + DBG("Getting UST tracing event fields"); + + domain.type = LTTNG_DOMAIN_UST; + + handle = lttng_create_handle(NULL, &domain); + if (handle == NULL) { + ret = CMD_ERROR; + goto end; + } + + size = lttng_list_tracepoint_fields(handle, &event_field_list); + if (size < 0) { + ERR("Unable to list UST event fields: %s", lttng_strerror(size)); + ret = CMD_ERROR; + goto end; + } + + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_ust_event_fields(event_field_list, size, &domain); + if (ret) { + ret = CMD_ERROR; + goto error; + } + } else { + /* Pretty print */ + MSG("UST events:\n-------------"); + + if (size == 0) { + MSG("None"); + } + + for (i = 0; i < size; i++) { + if (cur_pid != event_field_list[i].event.pid) { + cur_pid = event_field_list[i].event.pid; + cmdline = get_cmdline_by_pid(cur_pid); + if (cmdline == NULL) { + ret = CMD_ERROR; + goto error; + } + MSG("\nPID: %d - Name: %s", cur_pid, cmdline); + free(cmdline); + /* Wipe current event since we are about to print a new PID. */ + memset(&cur_event, 0, sizeof(cur_event)); + } + if (strcmp(cur_event.name, event_field_list[i].event.name) != 0) { + print_events(&event_field_list[i].event); + memcpy(&cur_event, &event_field_list[i].event, + sizeof(cur_event)); + } + print_event_field(&event_field_list[i]); + } + + MSG(""); + } + +error: + free(event_field_list); +end: + lttng_destroy_handle(handle); + return ret; +} + +/* + * Machine interface + * Print a list of kernel events + */ +static int mi_list_kernel_events(struct lttng_event *events, int count, + struct lttng_domain *domain) +{ + int ret, i; + + /* Open domains element */ + ret = mi_lttng_domains_open(writer); + if (ret) { + goto end; + } + + /* Write domain */ + ret = mi_lttng_domain(writer, domain, 1); + if (ret) { + goto end; + } + + /* Open events */ + ret = mi_lttng_events_open(writer); + if (ret) { + goto end; + } + + for (i = 0; i < count; i++) { + ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + if (ret) { + goto end; + } + } + + /* close events, domain and domains */ + ret = mi_lttng_close_multi_element(writer, 3); + if (ret) { + goto end; + } + +end: + return ret; +} + +/* + * Ask for all trace events in the kernel + */ +static int list_kernel_events(void) +{ + int i, size, ret = CMD_SUCCESS; + struct lttng_domain domain; + struct lttng_handle *handle; + struct lttng_event *event_list; + + memset(&domain, 0, sizeof(domain)); + + DBG("Getting kernel tracing events"); + + domain.type = LTTNG_DOMAIN_KERNEL; + + handle = lttng_create_handle(NULL, &domain); + if (handle == NULL) { + ret = CMD_ERROR; + goto error; + } + + size = lttng_list_tracepoints(handle, &event_list); + if (size < 0) { + ERR("Unable to list kernel events: %s", lttng_strerror(size)); + lttng_destroy_handle(handle); + return CMD_ERROR; + } + + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_kernel_events(event_list, size, &domain); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } else { + MSG("Kernel events:\n-------------"); + + for (i = 0; i < size; i++) { + print_events(&event_list[i]); + } + + MSG(""); + } + +end: + free(event_list); + + lttng_destroy_handle(handle); + return ret; + +error: + lttng_destroy_handle(handle); + return ret; +} + +/* + * Machine interface + * Print a list of system calls. + */ +static int mi_list_syscalls(struct lttng_event *events, int count) +{ + int ret, i; + + /* Open events */ + ret = mi_lttng_events_open(writer); + if (ret) { + goto end; + } + + for (i = 0; i < count; i++) { + ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + if (ret) { + goto end; + } + } + + /* Close events. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto end; + } + +end: + return ret; +} + +/* + * Ask for kernel system calls. + */ +static int list_syscalls(void) +{ + int i, size, ret = CMD_SUCCESS; + struct lttng_event *event_list; + + DBG("Getting kernel system call events"); + + size = lttng_list_syscalls(&event_list); + if (size < 0) { + ERR("Unable to list system calls: %s", lttng_strerror(size)); + ret = CMD_ERROR; + goto error; + } + + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_syscalls(event_list, size); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } else { + MSG("System calls:\n-------------"); + + for (i = 0; i < size; i++) { + print_events(&event_list[i]); + } + + MSG(""); + } + +end: + free(event_list); + return ret; + +error: + return ret; +} + +/* + * Machine Interface + * Print a list of agent events + */ +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); + if (ret) { + goto end; + } + + for (i = 0; i < count; i++) { + ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + if (ret) { + goto end; + } + } + + /* Close events element */ + ret = mi_lttng_writer_close_element(writer); + +end: + return ret; +} + +/* + * List agent events for a specific session using the handle. + * + * Return CMD_SUCCESS on success else a negative value. + */ +static int list_session_agent_events(void) +{ + int ret = CMD_SUCCESS, count, i; + struct lttng_event *events = NULL; + + count = lttng_list_events(handle, "", &events); + if (count < 0) { + ret = CMD_ERROR; + ERR("%s", lttng_strerror(count)); + goto error; + } + + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_session_agent_events(events, count); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } else { + /* Pretty print */ + MSG("Events (Logger name):\n---------------------"); + if (count == 0) { + MSG("%sNone\n", indent6); + goto end; + } + + for (i = 0; i < count; i++) { + const char *filter_str; + char *filter_msg = NULL; + struct lttng_event *event = &events[i]; + + ret = lttng_event_get_filter_expression(event, + &filter_str); + if (ret) { + filter_msg = strdup(" [failed to retrieve filter]"); + } else if (filter_str) { + const char * const filter_fmt = + " [filter: '%s']"; + + filter_msg = malloc(strlen(filter_str) + + strlen(filter_fmt) + 1); + if (filter_msg) { + sprintf(filter_msg, filter_fmt, + filter_str); + } + } + + if (event->loglevel_type != + LTTNG_EVENT_LOGLEVEL_ALL) { + MSG("%s- %s%s (loglevel%s %s)%s", indent4, + event->name, + enabled_string(event->enabled), + logleveltype_string( + event->loglevel_type), + mi_lttng_loglevel_string( + event->loglevel, + handle->domain.type), + safe_string(filter_msg)); + } else { + MSG("%s- %s%s%s", indent4, event->name, + enabled_string(event->enabled), + safe_string(filter_msg)); + } + free(filter_msg); + } + + MSG(""); + } + +end: + free(events); +error: + return ret; +} + +/* + * Machine interface + * print a list of event + */ +static int mi_list_events(struct lttng_event *events, int count) +{ + int ret, i; + + /* Open events element */ + ret = mi_lttng_events_open(writer); + if (ret) { + goto end; + } + + for (i = 0; i < count; i++) { + ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type); + if (ret) { + goto end; + } + } + + /* Close events element */ + ret = mi_lttng_writer_close_element(writer); + +end: + return ret; +} + +/* + * List events of channel of session and domain. + */ +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); + if (count < 0) { + ret = CMD_ERROR; + ERR("%s", lttng_strerror(count)); + goto error; + } + + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_events(events, count); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } else { + /* Pretty print */ + MSG("\n%sEvent rules:", indent4); + if (count == 0) { + MSG("%sNone\n", indent6); + goto end; + } + + for (i = 0; i < count; i++) { + print_events(&events[i]); + } + + MSG(""); + } +end: + free(events); +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); + } else { + MSG("inactive"); + } +} + +/* + * Pretty print channel + */ +static void print_channel(struct lttng_channel *channel) +{ + int ret; + uint64_t discarded_events, lost_packets, monitor_timer_interval; + int64_t blocking_timeout; + + ret = lttng_channel_get_discarded_event_count(channel, + &discarded_events); + if (ret) { + ERR("Failed to retrieve discarded event count of channel"); + return; + } + + ret = lttng_channel_get_lost_packet_count(channel, + &lost_packets); + if (ret) { + ERR("Failed to retrieve lost packet count of channel"); + return; + } + + 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("%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); + } + } + + 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 mode: splice", indent6); + break; + case LTTNG_EVENT_MMAP: + MSG("%sOutput mode: mmap", indent6); + break; + } + + MSG("\n%sStatistics:", indent4); + if (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; +} + +/* + * Machine interface + * Print a list of channel + * + */ +static int mi_list_channels(struct lttng_channel *channels, int count, + const char *channel_name) +{ + int i, ret; + unsigned int chan_found = 0; + + /* Open channels element */ + ret = mi_lttng_channels_open(writer); + if (ret) { + goto error; + } + + for (i = 0; i < count; i++) { + if (channel_name != NULL) { + if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) { + chan_found = 1; + } else { + continue; + } + } + + /* Write channel element and leave it open */ + ret = mi_lttng_channel(writer, &channels[i], 1); + if (ret) { + goto error; + } + + /* Listing events per channel */ + ret = list_events(channels[i].name); + if (ret) { + goto error; + } + + /* Closing the channel element we opened earlier */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto error; + } + + if (chan_found) { + break; + } + } + + /* Close channels element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto error; + } + +error: + return ret; +} + +/* + * List channel(s) of session and domain. + * + * If channel_name is NULL, all channels are listed. + */ +static int list_channels(const char *channel_name) +{ + int count, i, ret = CMD_SUCCESS; + unsigned int chan_found = 0; + struct lttng_channel *channels = NULL; + + DBG("Listing channel(s) (%s)", channel_name ? : ""); + + count = lttng_list_channels(handle, &channels); + if (count < 0) { + switch (-count) { + case LTTNG_ERR_KERN_CHAN_NOT_FOUND: + if (lttng_opt_mi) { + /* When printing mi this is not an error + * but an empty channels element */ + count = 0; + } else { + ret = CMD_SUCCESS; + WARN("No kernel channel"); + goto error_channels; + } + break; + default: + /* We had a real error */ + ret = CMD_ERROR; + ERR("%s", lttng_strerror(count)); + goto error_channels; + break; + } + } + + if (lttng_opt_mi) { + /* Mi print */ + ret = mi_list_channels(channels, count, channel_name); + if (ret) { + ret = CMD_ERROR; + goto error; + } + } else { + /* Pretty print */ + if (count) { + MSG("Channels:\n-------------"); + } + + for (i = 0; i < count; i++) { + if (channel_name != NULL) { + if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) { + chan_found = 1; + } else { + continue; + } + } + print_channel(&channels[i]); + + /* Listing events per channel */ + ret = list_events(channels[i].name); + if (ret) { + goto error; + } + + if (chan_found) { + break; + } + } + + if (!chan_found && channel_name != NULL) { + ret = CMD_ERROR; + ERR("Channel %s not found", channel_name); + goto error; + } + } +error: + free(channels); + +error_channels: + return ret; +} + +/* + * List tracker PID(s) of session and domain. + */ +static int list_tracker_pids(void) +{ + int ret = 0; + int enabled; + int *pids = NULL; + size_t nr_pids; + + ret = lttng_list_tracker_pids(handle, + &enabled, &pids, &nr_pids); + if (ret) { + return ret; + } + 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; + } + } + + for (i = 0; i < nr_pids; i++) { + if (i) { + _MSG(","); + } + _MSG(" %d", pids[i]); + + /* Mi */ + if (writer) { + ret = mi_lttng_pid_target(writer, pids[i], 0); + if (ret) { + goto end; + } + } + } + _MSG(" ]\n\n"); + + /* Mi close tracker_pid and targets */ + if (writer) { + ret = mi_lttng_close_multi_element(writer,2); + if (ret) { + goto end; + } + } + } +end: + free(pids); + return ret; + +} + +/* + * List all tracker of a domain + */ +static int list_trackers(void) +{ + int ret; + + /* Trackers listing */ + if (lttng_opt_mi) { + ret = mi_lttng_trackers_open(writer); + if (ret) { + goto end; + } + } + + /* pid tracker */ + ret = list_tracker_pids(); + if (ret) { + goto end; + } + + if (lttng_opt_mi) { + /* Close trackers element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto end; + } + } + +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); + 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; +} - lttng_destroy_handle(handle); - return CMD_SUCCESS; +static enum cmd_error_code print_rotation_schedule( + const struct lttng_rotation_schedule *schedule) +{ + enum cmd_error_code ret; -error: - lttng_destroy_handle(handle); - return -1; + 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 events of channel of session and domain. + * List the automatic rotation settings. */ -static int list_events(const char *channel_name) +static enum cmd_error_code list_rotate_settings(const char *session_name) { - int ret, count, i; - struct lttng_event *events = NULL; + 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; + } - count = lttng_list_events(handle, channel_name, &events); - if (count < 0) { - ret = count; - goto error; + 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; } - MSG("\n%sEvents:", indent4); if (count == 0) { - MSG("%sNone\n", indent6); + cmd_ret = CMD_SUCCESS; goto end; } - for (i = 0; i < count; i++) { - print_events(&events[i]); + MSG("Automatic rotation schedules:"); + if (lttng_opt_mi) { + ret = mi_lttng_writer_open_element(writer, + mi_lttng_element_rotation_schedules); + if (ret) { + cmd_ret = CMD_ERROR; + goto end; + } } - MSG(""); + 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; + } -end: - if (events) { - free(events); + if (lttng_opt_mi) { + ret = mi_lttng_rotation_schedule(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; } - ret = CMD_SUCCESS; -error: - return ret; + _MSG("\n"); + if (lttng_opt_mi) { + /* Close the rotation_schedules element. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + cmd_ret = CMD_ERROR; + goto end; + } + } +end: + lttng_rotation_schedules_destroy(schedules); + return cmd_ret; } /* - * Pretty print channel + * Machine interface + * Find the session with session_name as name + * and print his informations. */ -static void print_channel(struct lttng_channel *channel) +static int mi_list_session(const char *session_name, + struct lttng_session *sessions, int count) { - MSG("- %s:%s\n", channel->name, enabled_string(channel->enabled)); + int ret, i; + unsigned int session_found = 0; - 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); - switch (channel->attr.output) { - case LTTNG_EVENT_SPLICE: - MSG("%soutput: splice()", indent6); - break; - case LTTNG_EVENT_MMAP: - MSG("%soutput: mmap()", indent6); + if (session_name == NULL) { + ret = -LTTNG_ERR_SESS_NOT_FOUND; + goto end; + } + + for (i = 0; i < count; i++) { + if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { + /* 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); + if (ret) { + goto end; + } break; + } } + + if (!session_found) { + ERR("Session '%s' not found", session_name); + ret = -LTTNG_ERR_SESS_NOT_FOUND; + goto end; + } + +end: + return ret; } /* - * List channel(s) of session and domain. - * - * If channel_name is NULL, all channels are listed. + * Machine interface + * List all availables session */ -static int list_channels(const char *channel_name) +static int mi_list_sessions(struct lttng_session *sessions, int count) { - int count, i, ret = CMD_SUCCESS; - unsigned int chan_found = 0; - struct lttng_channel *channels = NULL; - - DBG("Listing channel(s) (%s)", channel_name ? : ""); + int ret, i; - count = lttng_list_channels(handle, &channels); - if (count < 0) { - ret = count; - goto error_channels; - } else if (count == 0) { - ERR("Channel %s not found", channel_name); - goto error; - } - - if (channel_name == NULL) { - MSG("Channels:\n-------------"); + /* Opening sessions element */ + ret = mi_lttng_sessions_open(writer); + if (ret) { + goto end; } + /* Listing sessions */ for (i = 0; i < count; i++) { - if (channel_name != NULL) { - if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) { - chan_found = 1; - } else { - continue; - } - } - print_channel(&channels[i]); - - /* Listing events per channel */ - ret = list_events(channels[i].name); - if (ret < 0) { - MSG("%s", lttng_strerror(ret)); - } - - if (chan_found) { - break; + ret = mi_lttng_session(writer, &sessions[i], 0); + if (ret) { + goto end; } } - if (!chan_found && channel_name != NULL) { - ERR("Channel %s not found", channel_name); - goto error; + /* Closing sessions element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto end; } - ret = CMD_SUCCESS; - -error: - free(channels); - -error_channels: +end: return ret; } @@ -465,59 +1820,114 @@ error_channels: */ static int list_sessions(const char *session_name) { - int ret, count, i; + int ret = CMD_SUCCESS; + int count, i; unsigned int session_found = 0; struct lttng_session *sessions; count = lttng_list_sessions(&sessions); DBG("Session count %d", count); if (count < 0) { - ret = count; - goto error; - } else if (count == 0) { - MSG("Currently no available tracing session"); + ret = CMD_ERROR; + ERR("%s", lttng_strerror(count)); goto end; } - if (session_name == NULL) { - MSG("Available tracing sessions:"); - } + if (lttng_opt_mi) { + /* Mi */ + if (session_name == NULL) { + /* List all session */ + ret = mi_list_sessions(sessions, count); + } else { + /* Note : this return an open session element */ + ret = mi_list_session(session_name, sessions, count); + } + if (ret) { + ret = CMD_ERROR; + goto error; + } + } else { + /* Pretty print */ + if (count == 0) { + MSG("Currently no available tracing session"); + goto end; + } - for (i = 0; i < count; i++) { - if (session_name != NULL) { - if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { - session_found = 1; - MSG("Tracing session %s:%s", session_name, active_string(sessions[i].enabled)); - MSG("%sTrace path: %s\n", indent4, sessions[i].path); - break; + if (session_name == NULL) { + MSG("Available tracing sessions:"); + } + + + for (i = 0; i < count; i++) { + if (session_name != NULL) { + if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { + session_found = 1; + 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); + memcpy(&listed_session, &sessions[i], + sizeof(listed_session)); + break; + } + } else { + MSG(" %d) %s (%s) [%s%s]", i + 1, + sessions[i].name, sessions[i].path, + active_string(sessions[i].enabled), + snapshot_string(sessions[i].snapshot_mode)); + MSG("%sTrace path: %s", indent4, sessions[i].path); + if (sessions[i].live_timer_interval != 0) { + MSG("%sLive timer interval: %u µs", indent4, + sessions[i].live_timer_interval); + } + MSG(""); } - continue; } - MSG(" %d) %s (%s)%s", i + 1, sessions[i].name, sessions[i].path, - active_string(sessions[i].enabled)); + if (!session_found && session_name != NULL) { + ERR("Session '%s' not found", session_name); + ret = CMD_ERROR; + goto error; + } - if (session_found) { - break; + if (session_name == NULL) { + MSG("\nUse lttng list for more details"); } } +error: free(sessions); +end: + return ret; +} - if (!session_found && session_name != NULL) { - ERR("Session '%s' not found", session_name); - ret = CMD_ERROR; - goto error; + +/* + * Machine Interface + * list available domain(s) for a session. + */ +static int mi_list_domains(struct lttng_domain *domains, int count) +{ + int i, ret; + /* Open domains element */ + ret = mi_lttng_domains_open(writer); + if (ret) { + goto end; } - if (session_name == NULL) { - MSG("\nUse lttng list for more details"); + for (i = 0; i < count; i++) { + ret = mi_lttng_domain(writer, &domains[i] , 0); + if (ret) { + goto end; + } } + /* Closing domains element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto end; + } end: - return CMD_SUCCESS; - -error: return ret; } @@ -529,34 +1939,56 @@ static int list_domains(const char *session_name) int i, count, ret = CMD_SUCCESS; struct lttng_domain *domains = NULL; - MSG("Domains:\n-------------"); count = lttng_list_domains(session_name, &domains); if (count < 0) { - ret = count; - goto error; - } else if (count == 0) { - MSG(" None"); + ret = CMD_ERROR; + ERR("%s", lttng_strerror(count)); goto end; } - for (i = 0; i < count; i++) { - switch (domains[i].type) { - case LTTNG_DOMAIN_KERNEL: - MSG(" - Kernel"); - break; - case LTTNG_DOMAIN_UST: - MSG(" - UST global"); - break; - default: - break; + if (lttng_opt_mi) { + /* Mi output */ + ret = mi_list_domains(domains, count); + if (ret) { + ret = CMD_ERROR; + goto error; + } + } else { + /* Pretty print */ + MSG("Domains:\n-------------"); + if (count == 0) { + MSG(" None"); + goto end; + } + + for (i = 0; i < count; i++) { + switch (domains[i].type) { + case LTTNG_DOMAIN_KERNEL: + MSG(" - Kernel"); + break; + case LTTNG_DOMAIN_UST: + MSG(" - UST global"); + break; + case LTTNG_DOMAIN_JUL: + MSG(" - JUL (Java Util Logging)"); + break; + case LTTNG_DOMAIN_LOG4J: + MSG(" - LOG4j (Logging for Java)"); + break; + case LTTNG_DOMAIN_PYTHON: + MSG(" - Python (logging)"); + break; + default: + break; + } } } -end: +error: free(domains); -error: +end: return ret; } @@ -565,9 +1997,8 @@ error: */ int cmd_list(int argc, const char **argv) { - int opt, i, ret = CMD_SUCCESS; - int nb_domain; - const char *session_name; + int opt, ret = CMD_SUCCESS; + const char *session_name, *leftover = NULL; static poptContext pc; struct lttng_domain domain; struct lttng_domain *domains = NULL; @@ -575,7 +2006,6 @@ int cmd_list(int argc, const char **argv) memset(&domain, 0, sizeof(domain)); if (argc < 1) { - usage(stderr); ret = CMD_ERROR; goto end; } @@ -586,7 +2016,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; @@ -595,24 +2025,68 @@ int cmd_list(int argc, const char **argv) list_cmd_options(stdout, long_options); goto end; default: - usage(stderr); ret = CMD_UNDEFINED; goto end; } } + /* Mi check */ + if (lttng_opt_mi) { + writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi); + if (!writer) { + ret = CMD_ERROR; + goto end; + } + + /* Open command element */ + ret = mi_lttng_writer_command_open(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); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } + /* Get session name (trailing argument) */ 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) { DBG2("Listing userspace global domain"); domain.type = LTTNG_DOMAIN_UST; + } else if (opt_jul) { + DBG2("Listing JUL domain"); + domain.type = LTTNG_DOMAIN_JUL; + } else if (opt_log4j) { + domain.type = LTTNG_DOMAIN_LOG4J; + } else if (opt_python) { + domain.type = LTTNG_DOMAIN_PYTHON; + } + + if (!opt_kernel && opt_syscall) { + WARN("--syscall will only work with the Kernel domain (-k)"); + ret = CMD_ERROR; + goto end; } - if (opt_kernel || opt_userspace) { + if (opt_kernel || opt_userspace || opt_jul || opt_log4j || opt_python) { handle = lttng_create_handle(session_name, &domain); if (handle == NULL) { ret = CMD_FATAL; @@ -621,28 +2095,60 @@ int cmd_list(int argc, const char **argv) } if (session_name == NULL) { - if (!opt_kernel && !opt_userspace) { + if (!opt_kernel && !opt_userspace && !opt_jul && !opt_log4j + && !opt_python) { ret = list_sessions(NULL); - if (ret != 0) { + if (ret) { goto end; } } if (opt_kernel) { - ret = list_kernel_events(); - if (ret < 0) { - goto end; + if (opt_syscall) { + ret = list_syscalls(); + if (ret) { + goto end; + } + } else { + ret = list_kernel_events(); + if (ret) { + goto end; + } } } if (opt_userspace) { - ret = list_ust_events(); - if (ret < 0) { + if (opt_fields) { + ret = list_ust_event_fields(); + } else { + ret = list_ust_events(); + } + if (ret) { + goto end; + } + } + if (opt_jul || opt_log4j || opt_python) { + ret = list_agent_events(); + if (ret) { goto end; } } } else { /* List session attributes */ + if (lttng_opt_mi) { + /* Open element sessions + * Present for xml consistency */ + ret = mi_lttng_sessions_open(writer); + if (ret) { + goto end; + } + } + /* MI: the ouptut of list_sessions is an unclosed session element */ ret = list_sessions(session_name); - if (ret != 0) { + if (ret) { + goto end; + } + + ret = list_rotate_settings(session_name); + if (ret) { goto end; } @@ -652,20 +2158,67 @@ int cmd_list(int argc, const char **argv) goto end; } - if (opt_kernel) { - /* Channel listing */ + /* Channel listing */ + if (opt_kernel || opt_userspace) { + if (lttng_opt_mi) { + /* Add of domains and domain element for xml + * consistency and validation + */ + ret = mi_lttng_domains_open(writer); + if (ret) { + goto end; + } + + /* Open domain and leave it open for + * nested channels printing */ + ret = mi_lttng_domain(writer, &domain, 1); + if (ret) { + goto end; + } + + } + + + /* Trackers */ + ret = list_trackers(); + if (ret) { + goto end; + } + + /* Channels */ ret = list_channels(opt_channel); - if (ret < 0) { + if (ret) { + goto end; + } + + if (lttng_opt_mi) { + /* Close domain and domain element */ + ret = mi_lttng_close_multi_element(writer, 2); + } + if (ret) { goto end; } + + } else { + int i, nb_domain; + /* We want all domain(s) */ nb_domain = lttng_list_domains(session_name, &domains); if (nb_domain < 0) { - ret = nb_domain; + ret = CMD_ERROR; + ERR("%s", lttng_strerror(nb_domain)); goto end; } + if (lttng_opt_mi) { + ret = mi_lttng_domains_open(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } + for (i = 0; i < nb_domain; i++) { switch (domains[i].type) { case LTTNG_DOMAIN_KERNEL: @@ -673,12 +2226,32 @@ int cmd_list(int argc, const char **argv) break; case LTTNG_DOMAIN_UST: MSG("=== Domain: UST global ===\n"); + MSG("Buffer type: %s\n", + domains[i].buf_type == + LTTNG_BUFFER_PER_PID ? "per PID" : "per UID"); + break; + case LTTNG_DOMAIN_JUL: + MSG("=== Domain: JUL (Java Util Logging) ===\n"); + break; + case LTTNG_DOMAIN_LOG4J: + MSG("=== Domain: LOG4j (Logging for Java) ===\n"); + break; + case LTTNG_DOMAIN_PYTHON: + MSG("=== Domain: Python (logging) ===\n"); break; default: MSG("=== Domain: Unimplemented ===\n"); break; } + if (lttng_opt_mi) { + ret = mi_lttng_domain(writer, &domains[i], 1); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } + /* Clean handle before creating a new one */ if (handle) { lttng_destroy_handle(handle); @@ -690,18 +2263,80 @@ int cmd_list(int argc, const char **argv) goto end; } + if (domains[i].type == LTTNG_DOMAIN_JUL || + domains[i].type == LTTNG_DOMAIN_LOG4J || + domains[i].type == LTTNG_DOMAIN_PYTHON) { + ret = list_session_agent_events(); + if (ret) { + goto end; + } + + goto next_domain; + } + + switch (domains[i].type) { + case LTTNG_DOMAIN_KERNEL: + case LTTNG_DOMAIN_UST: + ret = list_trackers(); + if (ret) { + goto end; + } + break; + default: + break; + } + ret = list_channels(opt_channel); - if (ret < 0) { + if (ret) { + goto end; + } + +next_domain: + if (lttng_opt_mi) { + /* Close domain element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } + + } + if (lttng_opt_mi) { + /* Close the domains, session and sessions element */ + ret = mi_lttng_close_multi_element(writer, 3); + if (ret) { + ret = CMD_ERROR; goto end; } } } } + /* Mi closing */ + if (lttng_opt_mi) { + /* Close output element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Command element close */ + ret = mi_lttng_writer_command_close(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } end: - if (domains) { - free(domains); + /* Mi clean-up */ + if (writer && mi_lttng_writer_destroy(writer)) { + /* Preserve original error code */ + ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL; } + + free(domains); if (handle) { lttng_destroy_handle(handle); }