+ /* Open domains element */
+ ret = mi_lttng_domains_open(the_writer);
+ if (ret) {
+ goto end;
+ }
+
+ /* Write domain */
+ ret = mi_lttng_domain(the_writer, domain, 1);
+ if (ret) {
+ goto end;
+ }
+
+ /* Open pids element */
+ ret = mi_lttng_pids_open(the_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(
+ 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);
+ 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(the_writer, cur_pid, cmdline,
+ 1);
+ if (ret) {
+ goto error;
+ }
+
+ /* Open events element */
+ ret = mi_lttng_events_open(the_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(
+ the_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(the_writer, &cur_event, 1,
+ the_handle->domain.type);
+ if (ret) {
+ goto end;
+ }
+
+ /* Open a fields element */
+ ret = mi_lttng_event_fields_open(the_writer);
+ if (ret) {
+ goto end;
+ }
+ event_element_open = 1;
+ }
+ }
+
+ /* Print the event_field */
+ ret = mi_lttng_event_field(the_writer, &fields[i]);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ /* Close pids, domain, domains */
+ ret = mi_lttng_close_multi_element(the_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(the_writer);
+ if (ret) {
+ goto end;
+ }
+
+ /* Write domain */
+ ret = mi_lttng_domain(the_writer, domain, 1);
+ if (ret) {
+ goto end;
+ }
+
+ /* Open events */
+ ret = mi_lttng_events_open(the_writer);
+ if (ret) {
+ goto end;
+ }
+
+ for (i = 0; i < count; i++) {
+ ret = mi_lttng_event(the_writer, &events[i], 0,
+ the_handle->domain.type);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ /* close events, domain and domains */
+ ret = mi_lttng_close_multi_element(the_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(the_writer);
+ if (ret) {
+ goto end;
+ }
+
+ for (i = 0; i < count; i++) {
+ ret = mi_lttng_event(the_writer, &events[i], 0,
+ the_handle->domain.type);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ /* Close events. */
+ ret = mi_lttng_writer_close_element(the_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(the_writer);
+ if (ret) {
+ goto end;
+ }
+
+ for (i = 0; i < count; i++) {
+ ret = mi_lttng_event(the_writer, &events[i], 0,
+ the_handle->domain.type);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ /* Close events element */
+ ret = mi_lttng_writer_close_element(the_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(the_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,
+ 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));
+ }
+ 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(the_writer);
+ if (ret) {
+ goto end;
+ }
+
+ for (i = 0; i < count; i++) {
+ ret = mi_lttng_event(the_writer, &events[i], 0,
+ the_handle->domain.type);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ /* Close events element */
+ ret = mi_lttng_writer_close_element(the_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(the_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%sRecording event 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, USEC_UNIT);
+ } 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, USEC_UNIT);
+ }
+ }
+
+ MSG("%sTrace file count: %" PRIu64 " per stream", indent6,
+ channel->attr.tracefile_count == 0 ?
+ 1 : channel->attr.tracefile_count);
+ if (channel->attr.tracefile_size != 0 ) {
+ MSG("%sTrace file size: %" PRIu64 " bytes", indent6,
+ channel->attr.tracefile_size);
+ } else {
+ MSG("%sTrace file size: %s", indent6, "unlimited");
+ }
+ switch (channel->attr.output) {
+ case LTTNG_EVENT_SPLICE:
+ MSG("%sOutput mode: splice", indent6);
+ break;
+ case LTTNG_EVENT_MMAP:
+ MSG("%sOutput mode: mmap", indent6);
+ break;
+ }
+
+ MSG("\n%sStatistics:", indent4);
+ if (the_listed_session.snapshot_mode) {
+ /*
+ * The lost packet count is omitted for sessions in snapshot
+ * mode as it is misleading: it would indicate the number of
+ * packets that the consumer could not extract during the
+ * course of recording the snapshot. It does not have the
+ * same meaning as the "regular" lost packet count that
+ * would result from the consumer not keeping up with
+ * event production in an overwrite-mode channel.
+ *
+ * A more interesting statistic would be the number of
+ * packets lost between the first and last extracted
+ * packets of a given snapshot (which prevents most analyses).
+ */
+ MSG("%sNone", indent6);
+ goto skip_stats_printing;
+ }
+
+ if (!channel->attr.overwrite) {
+ MSG("%sDiscarded events: %" PRIu64, indent6, discarded_events);
+ } else {
+ MSG("%sLost packets: %" PRIu64, indent6, lost_packets);
+ }
+skip_stats_printing:
+ return;
+}
+
+/*
+ * 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(the_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(the_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(the_writer);
+ if (ret) {
+ goto error;
+ }
+
+ if (chan_found) {
+ break;
+ }
+ }
+
+ /* Close channels element */
+ ret = mi_lttng_writer_close_element(the_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 ? : "<all>");
+
+ count = lttng_list_channels(the_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;
+ 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;
+}
+
+static const char *get_capitalized_process_attr_str(enum lttng_process_attr process_attr)
+{
+ switch (process_attr) {
+ case LTTNG_PROCESS_ATTR_PROCESS_ID:
+ return "Process ID";
+ case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
+ return "Virtual process ID";
+ case LTTNG_PROCESS_ATTR_USER_ID:
+ return "User ID";
+ case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
+ return "Virtual user ID";
+ case LTTNG_PROCESS_ATTR_GROUP_ID:
+ return "Group ID";
+ case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
+ return "Virtual group ID";
+ default:
+ return "Unknown";
+ }
+ return NULL;
+}
+
+static int handle_process_attr_status(enum lttng_process_attr process_attr,
+ enum lttng_process_attr_tracker_handle_status status)
+{
+ int ret = CMD_SUCCESS;
+
+ switch (status) {
+ case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY:
+ case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK:
+ /* Carry on. */
+ break;
+ case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR:
+ ERR("Communication occurred while fetching %s tracker",
+ lttng_process_attr_to_string(process_attr));
+ ret = CMD_ERROR;
+ break;
+ case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST:
+ ERR("Failed to get the inclusion set of the %s tracker: session `%s` no longer exists",
+ lttng_process_attr_to_string(process_attr),
+ the_handle->session_name);
+ ret = CMD_ERROR;
+ break;
+ default:
+ ERR("Unknown error occurred while fetching the inclusion set of the %s tracker",
+ lttng_process_attr_to_string(process_attr));
+ ret = CMD_ERROR;
+ break;
+ }
+
+ return ret;
+}
+
+static int mi_output_empty_tracker(enum lttng_process_attr process_attr)
+{
+ int ret;
+
+ ret = mi_lttng_process_attribute_tracker_open(the_writer, process_attr);
+ if (ret) {
+ goto end;
+ }
+
+ ret = mi_lttng_close_multi_element(the_writer, 2);
+end:
+ return ret;
+}
+
+static inline bool is_value_type_name(
+ enum lttng_process_attr_value_type value_type)
+{
+ return value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ||
+ value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME;
+}
+
+/*
+ * List a process attribute tracker for a session and domain tuple.
+ */
+static int list_process_attr_tracker(enum lttng_process_attr process_attr)
+{
+ int ret = 0;
+ unsigned int count, i;
+ enum lttng_tracking_policy policy;
+ enum lttng_error_code ret_code;
+ enum lttng_process_attr_tracker_handle_status handle_status;
+ enum lttng_process_attr_values_status values_status;
+ const struct lttng_process_attr_values *values;
+ struct lttng_process_attr_tracker_handle *tracker_handle = NULL;
+
+ ret_code = lttng_session_get_tracker_handle(the_handle->session_name,
+ the_handle->domain.type, process_attr, &tracker_handle);
+ if (ret_code != LTTNG_OK) {
+ ERR("Failed to get process attribute tracker handle: %s",
+ lttng_strerror(ret_code));
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ 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);
+ ret = handle_process_attr_status(process_attr, handle_status);
+ if (ret != CMD_SUCCESS) {
+ goto end;
+ }
+
+ {
+ char *process_attr_name;
+ const int print_ret = asprintf(&process_attr_name, "%ss:",
+ get_capitalized_process_attr_str(process_attr));
+
+ if (print_ret == -1) {
+ ret = CMD_FATAL;
+ goto end;
+ }
+ _MSG(" %-22s", process_attr_name);
+ free(process_attr_name);
+ }
+ switch (policy) {
+ case LTTNG_TRACKING_POLICY_INCLUDE_SET:
+ break;
+ case LTTNG_TRACKING_POLICY_EXCLUDE_ALL:
+ if (the_writer) {
+ mi_output_empty_tracker(process_attr);
+ }
+ MSG("none");
+ ret = CMD_SUCCESS;
+ goto end;
+ case LTTNG_TRACKING_POLICY_INCLUDE_ALL:
+ MSG("all");
+ ret = CMD_SUCCESS;
+ goto end;
+ default:
+ ERR("Unknown tracking policy encoutered while listing the %s process attribute tracker of session `%s`",
+ lttng_process_attr_to_string(process_attr),
+ the_handle->session_name);
+ ret = CMD_FATAL;
+ goto end;
+ }
+
+ values_status = lttng_process_attr_values_get_count(values, &count);
+ if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) {
+ ERR("Failed to get the count of values in the inclusion set of the %s process attribute tracker of session `%s`",
+ lttng_process_attr_to_string(process_attr),
+ the_handle->session_name);
+ ret = CMD_FATAL;
+ goto end;
+ }
+
+ if (count == 0) {
+ /* Functionally equivalent to the 'exclude all' policy. */
+ if (the_writer) {
+ mi_output_empty_tracker(process_attr);
+ }
+ MSG("none");
+ ret = CMD_SUCCESS;
+ goto end;
+ }
+
+ /* Mi tracker_id element */
+ if (the_writer) {
+ /* Open tracker_id and targets elements */
+ ret = mi_lttng_process_attribute_tracker_open(
+ the_writer, process_attr);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ for (i = 0; i < count; i++) {
+ const enum lttng_process_attr_value_type value_type =
+ lttng_process_attr_values_get_type_at_index(
+ values, i);
+ int64_t integral_value = INT64_MAX;
+ const char *name = "error";
+
+ if (i >= 1) {
+ _MSG(", ");
+ }
+ switch (value_type) {
+ case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
+ {
+ pid_t pid;
+
+ values_status = lttng_process_attr_values_get_pid_at_index(
+ values, i, &pid);
+ integral_value = (int64_t) pid;
+ break;
+ }
+ case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
+ {
+ uid_t uid;
+
+ values_status = lttng_process_attr_values_get_uid_at_index(
+ values, i, &uid);
+ integral_value = (int64_t) uid;
+ break;
+ }
+ case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
+ {
+ gid_t gid;
+
+ values_status = lttng_process_attr_values_get_gid_at_index(
+ values, i, &gid);
+ integral_value = (int64_t) gid;
+ break;
+ }
+ case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
+ values_status = lttng_process_attr_values_get_user_name_at_index(
+ values, i, &name);
+ break;
+ case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
+ values_status = lttng_process_attr_values_get_group_name_at_index(
+ values, i, &name);
+ break;
+ default:
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) {
+ /*
+ * Not possible given the current liblttng-ctl
+ * implementation.
+ */
+ ERR("Unknown error occurred while fetching process attribute value in inclusion list");
+ ret = CMD_FATAL;
+ goto end;
+ }
+
+ if (is_value_type_name(value_type)) {
+ _MSG("`%s`", name);
+ } else {
+ _MSG("%" PRIi64, integral_value);
+ }
+
+ /* Mi */
+ if (the_writer) {
+ ret = is_value_type_name(value_type) ?
+ mi_lttng_string_process_attribute_value(
+ the_writer,
+ process_attr, name,
+ false) :
+ mi_lttng_integral_process_attribute_value(
+ the_writer,
+ process_attr,
+ integral_value, false);
+ if (ret) {
+ goto end;
+ }
+ }
+ }
+ MSG("");
+
+ /* Mi close tracker_id and targets */
+ if (the_writer) {
+ ret = mi_lttng_close_multi_element(the_writer, 2);
+ if (ret) {
+ goto end;
+ }
+ }
+end:
+ lttng_process_attr_tracker_handle_destroy(tracker_handle);
+ return ret;
+}
+
+/*
+ * List all trackers of a domain
+ */
+static int list_trackers(const struct lttng_domain *domain)
+{
+ int ret = 0;
+
+ MSG("Tracked process attributes");
+ /* Trackers listing */
+ if (lttng_opt_mi) {
+ ret = mi_lttng_trackers_open(the_writer);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ switch (domain->type) {
+ case LTTNG_DOMAIN_KERNEL:
+ /* pid tracker */
+ ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_PROCESS_ID);
+ if (ret) {
+ goto end;
+ }
+ /* vpid tracker */
+ ret = list_process_attr_tracker(
+ LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID);
+ if (ret) {
+ goto end;
+ }
+ /* uid tracker */
+ ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_USER_ID);
+ if (ret) {
+ goto end;
+ }
+ /* vuid tracker */
+ ret = list_process_attr_tracker(
+ LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID);
+ if (ret) {
+ goto end;
+ }
+ /* gid tracker */
+ ret = list_process_attr_tracker(LTTNG_PROCESS_ATTR_GROUP_ID);
+ if (ret) {
+ goto end;
+ }
+ /* vgid tracker */
+ ret = list_process_attr_tracker(
+ LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID);
+ if (ret) {
+ goto end;
+ }
+ break;
+ case LTTNG_DOMAIN_UST:
+ /* vpid tracker */
+ ret = list_process_attr_tracker(
+ LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID);
+ if (ret) {
+ goto end;
+ }
+ /* vuid tracker */
+ ret = list_process_attr_tracker(
+ LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID);
+ if (ret) {
+ goto end;
+ }
+ /* vgid tracker */
+ ret = list_process_attr_tracker(
+ LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID);
+ if (ret) {
+ goto end;
+ }
+ break;
+ default:
+ break;
+ }
+ MSG();
+ if (lttng_opt_mi) {
+ /* Close trackers element */
+ ret = mi_lttng_writer_close_element(the_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, USEC_UNIT);
+ ret = CMD_SUCCESS;
+end:
+ return ret;
+}
+
+static enum cmd_error_code print_size_threshold_rotation_schedule(
+ const struct lttng_rotation_schedule *schedule)
+{
+ enum cmd_error_code ret;
+ enum lttng_rotation_status status;
+ uint64_t value;
+
+ status = lttng_rotation_schedule_size_threshold_get_threshold(schedule,
+ &value);
+ if (status != LTTNG_ROTATION_STATUS_OK) {
+ ERR("Failed to retrieve size parameter from size-based rotation schedule.");
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ MSG(" size threshold: %" PRIu64" bytes", value);
+ ret = CMD_SUCCESS;
+end:
+ return ret;
+}
+
+static enum cmd_error_code print_rotation_schedule(
+ const struct lttng_rotation_schedule *schedule)
+{
+ enum cmd_error_code ret;
+
+ switch (lttng_rotation_schedule_get_type(schedule)) {
+ case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
+ ret = print_size_threshold_rotation_schedule(schedule);
+ break;
+ case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
+ ret = print_periodic_rotation_schedule(schedule);
+ break;
+ default:
+ ret = CMD_ERROR;
+ }
+ return ret;