X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Flist.cpp;h=c4e52b78fef879d9edf902bf25e4dc63c50d28af;hb=cd9adb8b829564212158943a0d279bb35322ab30;hp=4bb681e09c1a9dca8850242dfc156c98beb8e62e;hpb=48a4000561343808724f7cb5fa8c131877489ccd;p=lttng-tools.git diff --git a/src/bin/lttng/commands/list.cpp b/src/bin/lttng/commands/list.cpp index 4bb681e09..c4e52b78f 100644 --- a/src/bin/lttng/commands/list.cpp +++ b/src/bin/lttng/commands/list.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 David Goulet + * Copyright (C) 2011 EfficiOS Inc. * Copyright (C) 2020 Jérémie Galarneau * * SPDX-License-Identifier: GPL-2.0-only @@ -8,20 +8,21 @@ #include #define _LGPL_SOURCE +#include "../command.hpp" + +#include +#include +#include + +#include +#include + #include #include #include #include #include -#include -#include -#include -#include -#include - -#include "../command.h" - static int opt_userspace; static int opt_kernel; static int opt_jul; @@ -39,7 +40,7 @@ const char *indent8 = " "; #ifdef LTTNG_EMBED_HELP static const char help_msg[] = #include -; + ; #endif enum { @@ -56,18 +57,18 @@ static struct lttng_session the_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}, - {"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} + { "help", 'h', POPT_ARG_NONE, nullptr, OPT_HELP, nullptr, nullptr }, + { "kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, nullptr, nullptr }, + { "jul", 'j', POPT_ARG_VAL, &opt_jul, 1, nullptr, nullptr }, + { "log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, nullptr, nullptr }, + { "python", 'p', POPT_ARG_VAL, &opt_python, 1, nullptr, nullptr }, + { "userspace", 'u', POPT_ARG_NONE, nullptr, OPT_USERSPACE, nullptr, nullptr }, + { "channel", 'c', POPT_ARG_STRING, &opt_channel, 0, nullptr, nullptr }, + { "domain", 'd', POPT_ARG_VAL, &opt_domain, 1, nullptr, nullptr }, + { "fields", 'f', POPT_ARG_VAL, &opt_fields, 1, nullptr, nullptr }, + { "syscall", 'S', POPT_ARG_VAL, &opt_syscall, 1, nullptr, nullptr }, + { "list-options", 0, POPT_ARG_NONE, nullptr, OPT_LIST_OPTIONS, nullptr, nullptr }, + { nullptr, 0, 0, nullptr, 0, nullptr, nullptr } }; /* @@ -79,23 +80,24 @@ static struct poptOption long_options[] = { static char *get_cmdline_by_pid(pid_t pid) { int ret; - FILE *fp = NULL; - char *cmdline = NULL; + FILE *fp = nullptr; + char *cmdline = nullptr; /* 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"); - if (fp == NULL) { + if (fp == nullptr) { goto end; } /* Caller must free() *cmdline */ - cmdline = (char *) zmalloc(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"); @@ -108,14 +110,17 @@ end: return cmdline; } -static -const char *active_string(int value) +static const char *active_string(int value) { switch (value) { - case 0: return "inactive"; - case 1: return "active"; - case -1: return ""; - default: return NULL; + case 0: + return "inactive"; + case 1: + return "active"; + case -1: + return ""; + default: + return nullptr; } } @@ -129,19 +134,21 @@ static const char *snapshot_string(int value) } } -static -const char *enabled_string(int value) +static const char *enabled_string(int value) { switch (value) { - case 0: return " [disabled]"; - case 1: return " [enabled]"; - case -1: return ""; - default: return NULL; + case 0: + return " [disabled]"; + case 1: + return " [enabled]"; + case -1: + return ""; + default: + return nullptr; } } -static -const char *safe_string(const char *str) +static const char *safe_string(const char *str) { return str ? str : ""; } @@ -184,10 +191,10 @@ static char *get_exclusion_names_msg(struct lttng_event *event) { int ret; int exclusion_count; - char *exclusion_msg = NULL; + char *exclusion_msg = nullptr; char *at; size_t i; - const char * const exclusion_fmt = " [exclusions: "; + const char *const exclusion_fmt = " [exclusions: "; const size_t exclusion_fmt_len = strlen(exclusion_fmt); exclusion_count = lttng_event_get_exclusion_name_count(event); @@ -207,9 +214,8 @@ static char *get_exclusion_names_msg(struct lttng_event *event) * a comma per entry, the entry count (fixed-size), a closing * bracket, and a trailing \0. */ - exclusion_msg = (char *) malloc(exclusion_count + - exclusion_count * LTTNG_SYMBOL_NAME_LEN + - exclusion_fmt_len + 1); + exclusion_msg = (char *) malloc(exclusion_count + exclusion_count * LTTNG_SYMBOL_NAME_LEN + + exclusion_fmt_len + 1); if (!exclusion_msg) { goto end; } @@ -276,7 +282,8 @@ static void print_userspace_probe_location(struct lttng_event *event) 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); + binary_path = realpath( + lttng_userspace_probe_location_function_get_binary_path(location), nullptr); MSG("%sBinary path: %s", indent8, binary_path ? binary_path : "NULL"); MSG("%sFunction: %s()", indent8, function_name ? function_name : "NULL"); @@ -302,10 +309,16 @@ static void print_userspace_probe_location(struct lttng_event *event) 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); + provider_name = + lttng_userspace_probe_location_tracepoint_get_provider_name(location); + binary_path = realpath( + lttng_userspace_probe_location_tracepoint_get_binary_path(location), + nullptr); 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"); + 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); @@ -330,21 +343,16 @@ static void print_events(struct lttng_event *event) { int ret; const char *filter_str; - char *filter_msg = NULL; - char *exclusion_msg = NULL; + char *filter_msg = nullptr; + char *exclusion_msg = nullptr; 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 = (char *) malloc(strlen(filter_str) + - strlen(filter_fmt) + 1); - if (filter_msg) { - sprintf(filter_msg, filter_fmt, - filter_str); + if (asprintf(&filter_msg, " [filter: '%s']", filter_str) == -1) { + filter_msg = nullptr; } } @@ -358,30 +366,30 @@ 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, - the_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, - event->name, - enabled_string(event->enabled), - safe_string(exclusion_msg), - safe_string(filter_msg)); + indent6, + event->name, + 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)); + 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 { @@ -390,9 +398,11 @@ static void print_events(struct lttng_event *event) } break; case LTTNG_EVENT_PROBE: - MSG("%s%s (type: probe)%s%s", indent6, - event->name, enabled_string(event->enabled), - safe_string(filter_msg)); + 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 { @@ -404,22 +414,27 @@ static void print_events(struct lttng_event *event) 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), - safe_string(filter_msg)); + 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("%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)); + 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%s", indent6, - enabled_string(event->enabled), - safe_string(filter_msg)); + MSG("%s (type: noop)%s%s", + indent6, + enabled_string(event->enabled), + safe_string(filter_msg)); break; case LTTNG_EVENT_ALL: /* Fall-through. */ @@ -435,7 +450,7 @@ static void print_events(struct lttng_event *event) static const char *field_type(struct lttng_event_field *field) { - switch(field->type) { + switch (field->type) { case LTTNG_EVENT_FIELD_INTEGER: return "integer"; case LTTNG_EVENT_FIELD_ENUM: @@ -445,7 +460,7 @@ static const char *field_type(struct lttng_event_field *field) case LTTNG_EVENT_FIELD_STRING: return "string"; case LTTNG_EVENT_FIELD_OTHER: - default: /* fall-through */ + default: /* fall-through */ return "unknown"; } } @@ -458,20 +473,23 @@ 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]" : ""); + 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) +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; + char *cmdline = nullptr; int pid_element_open = 0; /* Open domains element */ @@ -496,8 +514,7 @@ 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( - the_writer, 2); + ret = mi_lttng_close_multi_element(the_writer, 2); if (ret) { goto end; } @@ -513,8 +530,7 @@ 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(the_writer, cur_pid, cmdline, - 1); + ret = mi_lttng_pid(the_writer, cur_pid, cmdline, 1); if (ret) { goto error; } @@ -531,8 +547,7 @@ static int mi_list_agent_ust_events(struct lttng_event *events, int count, } /* Write an event */ - ret = mi_lttng_event(the_writer, &events[i], 0, - the_handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, the_handle->domain.type); if (ret) { goto end; } @@ -553,14 +568,14 @@ error: return ret; } -static int list_agent_events(void) +static int list_agent_events() { int i, size, ret = CMD_SUCCESS; struct lttng_domain domain; - struct lttng_handle *handle = NULL; - struct lttng_event *event_list = NULL; + struct lttng_handle *handle = nullptr; + struct lttng_event *event_list = nullptr; pid_t cur_pid = 0; - char *cmdline = NULL; + char *cmdline = nullptr; const char *agent_domain_str; memset(&domain, 0, sizeof(domain)); @@ -580,16 +595,15 @@ static int list_agent_events(void) DBG("Getting %s tracing events", agent_domain_str); - handle = lttng_create_handle(NULL, &domain); - if (handle == NULL) { + handle = lttng_create_handle(nullptr, &domain); + if (handle == nullptr) { ret = CMD_ERROR; goto end; } size = lttng_list_tracepoints(handle, &event_list); if (size < 0) { - ERR("Unable to list %s events: %s", agent_domain_str, - lttng_strerror(size)); + ERR("Unable to list %s events: %s", agent_domain_str, lttng_strerror(size)); ret = CMD_ERROR; goto end; } @@ -603,8 +617,7 @@ static int list_agent_events(void) } } else { /* Pretty print */ - MSG("%s events (Logger name):\n-------------------------", - agent_domain_str); + MSG("%s events (Logger name):\n-------------------------", agent_domain_str); if (size == 0) { MSG("None"); @@ -614,7 +627,7 @@ static int list_agent_events(void) if (cur_pid != event_list[i].pid) { cur_pid = event_list[i].pid; cmdline = get_cmdline_by_pid(cur_pid); - if (cmdline == NULL) { + if (cmdline == nullptr) { ret = CMD_ERROR; goto error; } @@ -637,14 +650,14 @@ end: /* * Ask session daemon for all user space tracepoints available. */ -static int list_ust_events(void) +static int list_ust_events() { int i, size, ret = CMD_SUCCESS; struct lttng_domain domain; struct lttng_handle *handle; - struct lttng_event *event_list = NULL; + struct lttng_event *event_list = nullptr; pid_t cur_pid = 0; - char *cmdline = NULL; + char *cmdline = nullptr; memset(&domain, 0, sizeof(domain)); @@ -652,8 +665,8 @@ static int list_ust_events(void) domain.type = LTTNG_DOMAIN_UST; - handle = lttng_create_handle(NULL, &domain); - if (handle == NULL) { + handle = lttng_create_handle(nullptr, &domain); + if (handle == nullptr) { ret = CMD_ERROR; goto end; } @@ -680,7 +693,7 @@ static int list_ust_events(void) if (cur_pid != event_list[i].pid) { cur_pid = event_list[i].pid; cmdline = get_cmdline_by_pid(cur_pid); - if (cmdline == NULL) { + if (cmdline == nullptr) { ret = CMD_ERROR; goto error; } @@ -704,12 +717,12 @@ end: * 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) +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; + char *cmdline = nullptr; int pid_element_open = 0; int event_element_open = 0; struct lttng_event cur_event; @@ -739,16 +752,14 @@ static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count, if (pid_element_open) { if (event_element_open) { /* Close the previous field element and event. */ - ret = mi_lttng_close_multi_element( - the_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( - the_writer, 2); + ret = mi_lttng_close_multi_element(the_writer, 2); if (ret) { goto end; } @@ -759,8 +770,7 @@ 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(the_writer, cur_pid, cmdline, - 1); + ret = mi_lttng_pid(the_writer, cur_pid, cmdline, 1); if (ret) { goto error; } @@ -780,21 +790,19 @@ 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( - the_writer, 2); + ret = mi_lttng_close_multi_element(the_writer, 2); if (ret) { goto end; } event_element_open = 0; } - memcpy(&cur_event, &fields[i].event, - sizeof(cur_event)); + memcpy(&cur_event, &fields[i].event, sizeof(cur_event)); if (!event_element_open) { /* Open and write the event */ - ret = mi_lttng_event(the_writer, &cur_event, 1, - the_handle->domain.type); + ret = mi_lttng_event( + the_writer, &cur_event, 1, the_handle->domain.type); if (ret) { goto end; } @@ -827,14 +835,14 @@ error: /* * Ask session daemon for all user space tracepoint fields available. */ -static int list_ust_event_fields(void) +static int list_ust_event_fields() { 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; + char *cmdline = nullptr; struct lttng_event cur_event; @@ -845,8 +853,8 @@ static int list_ust_event_fields(void) domain.type = LTTNG_DOMAIN_UST; - handle = lttng_create_handle(NULL, &domain); - if (handle == NULL) { + handle = lttng_create_handle(nullptr, &domain); + if (handle == nullptr) { ret = CMD_ERROR; goto end; } @@ -877,7 +885,7 @@ static int list_ust_event_fields(void) 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) { + if (cmdline == nullptr) { ret = CMD_ERROR; goto error; } @@ -888,8 +896,7 @@ static int list_ust_event_fields(void) } 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)); + memcpy(&cur_event, &event_field_list[i].event, sizeof(cur_event)); } print_event_field(&event_field_list[i]); } @@ -908,8 +915,7 @@ end: * Machine interface * Print a list of kernel events */ -static int mi_list_kernel_events(struct lttng_event *events, int count, - struct lttng_domain *domain) +static int mi_list_kernel_events(struct lttng_event *events, int count, struct lttng_domain *domain) { int ret, i; @@ -932,8 +938,7 @@ static int mi_list_kernel_events(struct lttng_event *events, int count, } for (i = 0; i < count; i++) { - ret = mi_lttng_event(the_writer, &events[i], 0, - the_handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, the_handle->domain.type); if (ret) { goto end; } @@ -952,7 +957,7 @@ end: /* * Ask for all trace events in the kernel */ -static int list_kernel_events(void) +static int list_kernel_events() { int i, size, ret = CMD_SUCCESS; struct lttng_domain domain; @@ -965,8 +970,8 @@ static int list_kernel_events(void) domain.type = LTTNG_DOMAIN_KERNEL; - handle = lttng_create_handle(NULL, &domain); - if (handle == NULL) { + handle = lttng_create_handle(nullptr, &domain); + if (handle == nullptr) { ret = CMD_ERROR; goto error; } @@ -1021,8 +1026,7 @@ static int mi_list_syscalls(struct lttng_event *events, int count) } for (i = 0; i < count; i++) { - ret = mi_lttng_event(the_writer, &events[i], 0, - the_handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, the_handle->domain.type); if (ret) { goto end; } @@ -1041,7 +1045,7 @@ end: /* * Ask for kernel system calls. */ -static int list_syscalls(void) +static int list_syscalls() { int i, size, ret = CMD_SUCCESS; struct lttng_event *event_list; @@ -1095,8 +1099,7 @@ static int mi_list_session_agent_events(struct lttng_event *events, int count) } for (i = 0; i < count; i++) { - ret = mi_lttng_event(the_writer, &events[i], 0, - the_handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, the_handle->domain.type); if (ret) { goto end; } @@ -1114,10 +1117,10 @@ end: * * Return CMD_SUCCESS on success else a negative value. */ -static int list_session_agent_events(void) +static int list_session_agent_events() { int ret = CMD_SUCCESS, count, i; - struct lttng_event *events = NULL; + struct lttng_event *events = nullptr; count = lttng_list_events(the_handle, "", &events); if (count < 0) { @@ -1143,41 +1146,33 @@ static int list_session_agent_events(void) for (i = 0; i < count; i++) { const char *filter_str; - char *filter_msg = NULL; + char *filter_msg = nullptr; struct lttng_event *event = &events[i]; - ret = lttng_event_get_filter_expression(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) { - const char * const filter_fmt = - " [filter: '%s']"; - - filter_msg = (char *) malloc(strlen(filter_str) + - strlen(filter_fmt) + 1); - if (filter_msg) { - sprintf(filter_msg, filter_fmt, - filter_str); + if (asprintf(&filter_msg, " [filter: '%s']", filter_str) == -1) { + filter_msg = nullptr; } } - 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, - the_handle->domain - .type), - safe_string(filter_msg)); + 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, + the_handle->domain.type), + safe_string(filter_msg)); } else { - MSG("%s- %s%s%s", indent4, event->name, - enabled_string(event->enabled), - safe_string(filter_msg)); + MSG("%s- %s%s%s", + indent4, + event->name, + enabled_string(event->enabled), + safe_string(filter_msg)); } free(filter_msg); } @@ -1206,8 +1201,7 @@ static int mi_list_events(struct lttng_event *events, int count) } for (i = 0; i < count; i++) { - ret = mi_lttng_event(the_writer, &events[i], 0, - the_handle->domain.type); + ret = mi_lttng_event(the_writer, &events[i], 0, the_handle->domain.type); if (ret) { goto end; } @@ -1226,7 +1220,7 @@ end: static int list_events(const char *channel_name) { int ret = CMD_SUCCESS, count, i; - struct lttng_event *events = NULL; + struct lttng_event *events = nullptr; count = lttng_list_events(the_handle, channel_name, &events); if (count < 0) { @@ -1262,8 +1256,7 @@ error: return ret; } -static -void print_timer(const char *timer_name, uint32_t space_count, int64_t value) +static void print_timer(const char *timer_name, uint32_t space_count, int64_t value) { uint32_t i; @@ -1288,29 +1281,25 @@ static void print_channel(struct lttng_channel *channel) uint64_t discarded_events, lost_packets, monitor_timer_interval; int64_t blocking_timeout; - ret = lttng_channel_get_discarded_event_count(channel, - &discarded_events); + 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); + 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); + 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); + ret = lttng_channel_get_blocking_timeout(channel, &blocking_timeout); if (ret) { ERR("Failed to retrieve blocking timeout of channel"); return; @@ -1323,34 +1312,35 @@ static void print_channel(struct lttng_channel *channel) 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("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("%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); + 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; + case LTTNG_EVENT_SPLICE: + MSG("%sOutput mode: splice", indent6); + break; + case LTTNG_EVENT_MMAP: + MSG("%sOutput mode: mmap", indent6); + break; } MSG("\n%sStatistics:", indent4); @@ -1386,8 +1376,7 @@ skip_stats_printing: * Print a list of channel * */ -static int mi_list_channels(struct lttng_channel *channels, int count, - const char *channel_name) +static int mi_list_channels(struct lttng_channel *channels, int count, const char *channel_name) { int i, ret; unsigned int chan_found = 0; @@ -1399,7 +1388,7 @@ static int mi_list_channels(struct lttng_channel *channels, int count, } for (i = 0; i < count; i++) { - if (channel_name != NULL) { + if (channel_name != nullptr) { if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) { chan_found = 1; } else { @@ -1449,9 +1438,9 @@ static int list_channels(const char *channel_name) { int count, i, ret = CMD_SUCCESS; unsigned int chan_found = 0; - struct lttng_channel *channels = NULL; + struct lttng_channel *channels = nullptr; - DBG("Listing channel(s) (%s)", channel_name ? : ""); + DBG("Listing channel(s) (%s)", channel_name ?: ""); count = lttng_list_channels(the_handle, &channels); if (count < 0) { @@ -1489,7 +1478,7 @@ static int list_channels(const char *channel_name) } for (i = 0; i < count; i++) { - if (channel_name != NULL) { + if (channel_name != nullptr) { if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) { chan_found = 1; } else { @@ -1509,7 +1498,7 @@ static int list_channels(const char *channel_name) } } - if (!chan_found && channel_name != NULL) { + if (!chan_found && channel_name != nullptr) { ret = CMD_ERROR; ERR("Channel %s not found", channel_name); goto error; @@ -1540,11 +1529,11 @@ static const char *get_capitalized_process_attr_str(enum lttng_process_attr proc default: return "Unknown"; } - return NULL; + return nullptr; } static int handle_process_attr_status(enum lttng_process_attr process_attr, - enum lttng_process_attr_tracker_handle_status status) + enum lttng_process_attr_tracker_handle_status status) { int ret = CMD_SUCCESS; @@ -1555,18 +1544,18 @@ static int handle_process_attr_status(enum lttng_process_attr process_attr, break; case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR: ERR("Communication occurred while fetching %s tracker", - lttng_process_attr_to_string(process_attr)); + 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); + 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)); + lttng_process_attr_to_string(process_attr)); ret = CMD_ERROR; break; } @@ -1588,11 +1577,10 @@ end: return ret; } -static inline bool is_value_type_name( - enum lttng_process_attr_value_type value_type) +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; + value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME; } /* @@ -1607,26 +1595,25 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) 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; + struct lttng_process_attr_tracker_handle *tracker_handle = nullptr; - ret_code = lttng_session_get_tracker_handle(the_handle->session_name, - the_handle->domain.type, process_attr, &tracker_handle); + 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)); + ERR("Failed to get process attribute tracker handle: %s", lttng_strerror(ret_code)); ret = CMD_ERROR; goto end; } - handle_status = lttng_process_attr_tracker_handle_get_inclusion_set( - tracker_handle, &values); + 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; } - handle_status = lttng_process_attr_tracker_handle_get_tracking_policy( - tracker_handle, &policy); + 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; @@ -1634,8 +1621,8 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) { char *process_attr_name; - const int print_ret = asprintf(&process_attr_name, "%ss:", - get_capitalized_process_attr_str(process_attr)); + const int print_ret = asprintf( + &process_attr_name, "%ss:", get_capitalized_process_attr_str(process_attr)); if (print_ret == -1) { ret = CMD_FATAL; @@ -1660,8 +1647,8 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) 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); + lttng_process_attr_to_string(process_attr), + the_handle->session_name); ret = CMD_FATAL; goto end; } @@ -1669,8 +1656,8 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) 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); + lttng_process_attr_to_string(process_attr), + the_handle->session_name); ret = CMD_FATAL; goto end; } @@ -1688,8 +1675,7 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) /* Mi tracker_id element */ if (the_writer) { /* Open tracker_id and targets elements */ - ret = mi_lttng_process_attribute_tracker_open( - the_writer, process_attr); + ret = mi_lttng_process_attribute_tracker_open(the_writer, process_attr); if (ret) { goto end; } @@ -1697,8 +1683,7 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) 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); + lttng_process_attr_values_get_type_at_index(values, i); int64_t integral_value = INT64_MAX; const char *name = "error"; @@ -1710,8 +1695,7 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) { pid_t pid; - values_status = lttng_process_attr_values_get_pid_at_index( - values, i, &pid); + values_status = lttng_process_attr_values_get_pid_at_index(values, i, &pid); integral_value = (int64_t) pid; break; } @@ -1719,8 +1703,7 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) { uid_t uid; - values_status = lttng_process_attr_values_get_uid_at_index( - values, i, &uid); + values_status = lttng_process_attr_values_get_uid_at_index(values, i, &uid); integral_value = (int64_t) uid; break; } @@ -1728,18 +1711,17 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) { gid_t gid; - values_status = lttng_process_attr_values_get_gid_at_index( - values, i, &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); + 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); + values_status = + lttng_process_attr_values_get_group_name_at_index(values, i, &name); break; default: ret = CMD_ERROR; @@ -1765,14 +1747,10 @@ static int list_process_attr_tracker(enum lttng_process_attr process_attr) /* 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); + 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; } @@ -1816,8 +1794,7 @@ static int list_trackers(const struct lttng_domain *domain) goto end; } /* vpid tracker */ - ret = list_process_attr_tracker( - LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID); + ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID); if (ret) { goto end; } @@ -1827,8 +1804,7 @@ static int list_trackers(const struct lttng_domain *domain) goto end; } /* vuid tracker */ - ret = list_process_attr_tracker( - LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID); + ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID); if (ret) { goto end; } @@ -1838,28 +1814,24 @@ static int list_trackers(const struct lttng_domain *domain) goto end; } /* vgid tracker */ - ret = list_process_attr_tracker( - LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID); + 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); + 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); + 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); + ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID); if (ret) { goto end; } @@ -1880,50 +1852,47 @@ end: return ret; } -static enum cmd_error_code print_periodic_rotation_schedule( - const struct lttng_rotation_schedule *schedule) +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); + 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); + 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) +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); + 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); + 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) +static enum cmd_error_code print_rotation_schedule(const struct lttng_rotation_schedule *schedule) { enum cmd_error_code ret; @@ -1948,7 +1917,7 @@ 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; + struct lttng_rotation_schedules *schedules = nullptr; enum lttng_rotation_status status; ret = lttng_session_list_rotation_schedules(session_name, &schedules); @@ -1972,8 +1941,7 @@ static enum cmd_error_code list_rotate_settings(const char *session_name) MSG("Automatic rotation schedules:"); if (lttng_opt_mi) { - ret = mi_lttng_writer_open_element(the_writer, - mi_lttng_element_rotation_schedules); + ret = mi_lttng_writer_open_element(the_writer, mi_lttng_element_rotation_schedules); if (ret) { cmd_ret = CMD_ERROR; goto end; @@ -2026,13 +1994,12 @@ end: * Find the session with session_name as name * and print his informations. */ -static int mi_list_session(const char *session_name, - struct lttng_session *sessions, int count) +static int mi_list_session(const char *session_name, struct lttng_session *sessions, int count) { int ret, i; unsigned int session_found = 0; - if (session_name == NULL) { + if (session_name == nullptr) { ret = -LTTNG_ERR_SESS_NOT_FOUND; goto end; } @@ -2102,7 +2069,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 = NULL; + struct lttng_session *sessions = nullptr; count = lttng_list_sessions(&sessions); DBG("Session count %d", count); @@ -2114,7 +2081,7 @@ static int list_sessions(const char *session_name) if (lttng_opt_mi) { /* Mi */ - if (session_name == NULL) { + if (session_name == nullptr) { /* List all sessions */ ret = mi_list_sessions(sessions, count); } else { @@ -2132,49 +2099,54 @@ static int list_sessions(const char *session_name) goto end; } - if (session_name == NULL) { + if (session_name == nullptr) { MSG("Available recording sessions:"); } for (i = 0; i < count; i++) { - if (session_name != NULL) { + if (session_name != nullptr) { if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { session_found = 1; - MSG("Recording session %s: [%s%s]", session_name, - active_string(sessions[i].enabled), - snapshot_string(sessions[i].snapshot_mode)); + MSG("Recording session %s: [%s%s]", + session_name, + active_string(sessions[i].enabled), + snapshot_string(sessions[i].snapshot_mode)); if (*sessions[i].path) { - MSG("%sTrace output: %s\n", indent4, sessions[i].path); + MSG("%sTrace output: %s\n", + indent4, + sessions[i].path); } memcpy(&the_listed_session, - &sessions[i], - sizeof(the_listed_session)); + &sessions[i], + sizeof(the_listed_session)); break; } } else { - MSG(" %d) %s [%s%s]", i + 1, - sessions[i].name, - active_string(sessions[i].enabled), - snapshot_string(sessions[i].snapshot_mode)); + MSG(" %d) %s [%s%s]", + i + 1, + sessions[i].name, + active_string(sessions[i].enabled), + snapshot_string(sessions[i].snapshot_mode)); if (*sessions[i].path) { MSG("%sTrace output: %s", indent4, sessions[i].path); } if (sessions[i].live_timer_interval != 0) { - MSG("%sLive timer interval: %u %s", indent4, - sessions[i].live_timer_interval, - USEC_UNIT); + MSG("%sLive timer interval: %u %s", + indent4, + sessions[i].live_timer_interval, + USEC_UNIT); } MSG(""); } } - if (!session_found && session_name != NULL) { + if (!session_found && session_name != nullptr) { ERR("Session '%s' not found", session_name); ret = CMD_ERROR; goto end; } - if (session_name == NULL) { + if (session_name == nullptr) { MSG("\nUse lttng list for more details"); } } @@ -2184,7 +2156,6 @@ end: return ret; } - /* * Machine Interface * list available domain(s) for a session. @@ -2220,8 +2191,7 @@ end: static int list_domains(const char *session_name) { int i, count, ret = CMD_SUCCESS; - struct lttng_domain *domains = NULL; - + struct lttng_domain *domains = nullptr; count = lttng_list_domains(session_name, &domains); if (count < 0) { @@ -2281,10 +2251,10 @@ end: int cmd_list(int argc, const char **argv) { int opt, ret = CMD_SUCCESS; - const char *session_name, *leftover = NULL; + const char *arg_session_name, *leftover = nullptr; static poptContext pc; struct lttng_domain domain; - struct lttng_domain *domains = NULL; + struct lttng_domain *domains = nullptr; memset(&domain, 0, sizeof(domain)); @@ -2293,7 +2263,7 @@ int cmd_list(int argc, const char **argv) goto end; } - pc = poptGetContext(NULL, argc, argv, long_options, 0); + pc = poptGetContext(nullptr, argc, argv, long_options, 0); poptReadDefaultConfig(pc, 0); while ((opt = poptGetNextOpt(pc)) != -1) { @@ -2315,24 +2285,21 @@ int cmd_list(int argc, const char **argv) /* Mi check */ if (lttng_opt_mi) { - the_writer = mi_lttng_writer_create( - fileno(stdout), lttng_opt_mi); + 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( - the_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( - the_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; @@ -2340,8 +2307,8 @@ int cmd_list(int argc, const char **argv) } /* Get session name (trailing argument) */ - session_name = poptGetArg(pc); - DBG2("Session name: %s", session_name); + arg_session_name = poptGetArg(pc); + DBG2("Session name: %s", arg_session_name); leftover = poptGetArg(pc); if (leftover) { @@ -2371,17 +2338,16 @@ int cmd_list(int argc, const char **argv) } if (opt_kernel || opt_userspace || opt_jul || opt_log4j || opt_python) { - the_handle = lttng_create_handle(session_name, &domain); - if (the_handle == NULL) { + the_handle = lttng_create_handle(arg_session_name, &domain); + if (the_handle == nullptr) { ret = CMD_FATAL; goto end; } } - if (session_name == NULL) { - if (!opt_kernel && !opt_userspace && !opt_jul && !opt_log4j - && !opt_python) { - ret = list_sessions(NULL); + if (arg_session_name == nullptr) { + if (!opt_kernel && !opt_userspace && !opt_jul && !opt_log4j && !opt_python) { + ret = list_sessions(nullptr); if (ret) { goto end; } @@ -2426,19 +2392,19 @@ int cmd_list(int argc, const char **argv) } } /* MI: the ouptut of list_sessions is an unclosed session element */ - ret = list_sessions(session_name); + ret = list_sessions(arg_session_name); if (ret) { goto end; } - ret = list_rotate_settings(session_name); + ret = list_rotate_settings(arg_session_name); if (ret) { goto end; } /* Domain listing */ if (opt_domain) { - ret = list_domains(session_name); + ret = list_domains(arg_session_name); goto end; } @@ -2459,10 +2425,8 @@ int cmd_list(int argc, const char **argv) if (ret) { goto end; } - } - /* Trackers */ ret = list_trackers(&domain); if (ret) { @@ -2477,19 +2441,17 @@ int cmd_list(int argc, const char **argv) if (lttng_opt_mi) { /* Close domain and domain element */ - ret = mi_lttng_close_multi_element( - the_writer, 2); + ret = mi_lttng_close_multi_element(the_writer, 2); } if (ret) { goto end; } - } else { int i, nb_domain; /* We want all domain(s) */ - nb_domain = lttng_list_domains(session_name, &domains); + nb_domain = lttng_list_domains(arg_session_name, &domains); if (nb_domain < 0) { ret = CMD_ERROR; ERR("%s", lttng_strerror(nb_domain)); @@ -2512,8 +2474,9 @@ int cmd_list(int argc, const char **argv) case LTTNG_DOMAIN_UST: MSG("=== Domain: User space ===\n"); MSG("Buffering scheme: %s\n", - domains[i].buf_type == - LTTNG_BUFFER_PER_PID ? "per-process" : "per-user"); + domains[i].buf_type == LTTNG_BUFFER_PER_PID ? + "per-process" : + "per-user"); break; case LTTNG_DOMAIN_JUL: MSG("=== Domain: java.util.logging (JUL) ===\n"); @@ -2530,8 +2493,7 @@ int cmd_list(int argc, const char **argv) } if (lttng_opt_mi) { - ret = mi_lttng_domain(the_writer, - &domains[i], 1); + ret = mi_lttng_domain(the_writer, &domains[i], 1); if (ret) { ret = CMD_ERROR; goto end; @@ -2543,16 +2505,15 @@ int cmd_list(int argc, const char **argv) lttng_destroy_handle(the_handle); } - the_handle = lttng_create_handle( - session_name, &domains[i]); - if (the_handle == NULL) { + the_handle = lttng_create_handle(arg_session_name, &domains[i]); + if (the_handle == nullptr) { ret = CMD_FATAL; goto end; } if (domains[i].type == LTTNG_DOMAIN_JUL || - domains[i].type == LTTNG_DOMAIN_LOG4J || - domains[i].type == LTTNG_DOMAIN_PYTHON) { + domains[i].type == LTTNG_DOMAIN_LOG4J || + domains[i].type == LTTNG_DOMAIN_PYTHON) { ret = list_session_agent_events(); if (ret) { goto end; @@ -2578,22 +2539,19 @@ int cmd_list(int argc, const char **argv) goto end; } -next_domain: + next_domain: if (lttng_opt_mi) { /* Close domain element */ - ret = mi_lttng_writer_close_element( - the_writer); + ret = mi_lttng_writer_close_element(the_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( - the_writer, 3); + ret = mi_lttng_close_multi_element(the_writer, 3); if (ret) { ret = CMD_ERROR; goto end;