+ 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 (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 ? : "<all>");
+
+ 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;
+}
+
+static const char *get_tracker_str(enum lttng_tracker_type tracker_type)
+{
+ switch (tracker_type) {
+ case LTTNG_TRACKER_PID:
+ return "PID";
+ case LTTNG_TRACKER_VPID:
+ return "VPID";
+ case LTTNG_TRACKER_UID:
+ return "UID";
+ case LTTNG_TRACKER_VUID:
+ return "VUID";
+ case LTTNG_TRACKER_GID:
+ return "GID";
+ case LTTNG_TRACKER_VGID:
+ return "VGID";
+ }
+ return NULL;
+}
+
+/*
+ * List tracker ID(s) of session and domain.
+ */
+static int list_tracker_ids(enum lttng_tracker_type tracker_type)
+{
+ int ret = 0;
+ int enabled = 1;
+ struct lttng_tracker_ids *ids = NULL;
+ unsigned int nr_ids, i;
+ const struct lttng_tracker_id *id;
+ enum lttng_tracker_id_status status;
+
+ ret = lttng_list_tracker_ids(handle, tracker_type, &ids);
+ if (ret) {
+ return ret;
+ }
+
+ status = lttng_tracker_ids_get_count(ids, &nr_ids);
+ if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ if (nr_ids == 1) {
+ id = lttng_tracker_ids_get_at_index(ids, 0);
+ if (id && lttng_tracker_id_get_type(id) == LTTNG_ID_ALL) {
+ enabled = 0;
+ }
+ }
+
+ if (enabled) {
+ _MSG("%s tracker: [", get_tracker_str(tracker_type));
+
+ /* Mi tracker_id element */
+ if (writer) {
+ /* Open tracker_id and targets elements */
+ ret = mi_lttng_id_tracker_open(writer, tracker_type);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ for (i = 0; i < nr_ids; i++) {
+ enum lttng_tracker_id_status status =
+ LTTNG_TRACKER_ID_STATUS_OK;
+ int value;
+ const char *value_string;
+
+ id = lttng_tracker_ids_get_at_index(ids, i);
+ if (!id) {
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ switch (lttng_tracker_id_get_type(id)) {
+ case LTTNG_ID_ALL:
+ break;
+ case LTTNG_ID_VALUE:
+ status = lttng_tracker_id_get_value(id, &value);
+ break;
+ case LTTNG_ID_STRING:
+ status = lttng_tracker_id_get_string(
+ id, &value_string);
+ break;
+ case LTTNG_ID_UNKNOWN:
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+ ERR("Invalid state for tracker id");
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ if (i) {
+ _MSG(",");
+ }
+ switch (lttng_tracker_id_get_type(id)) {
+ case LTTNG_ID_ALL:
+ _MSG(" *");
+ break;
+ case LTTNG_ID_VALUE:
+ _MSG(" %d", value);
+ break;
+ case LTTNG_ID_STRING:
+ _MSG(" %s", value_string);
+ break;
+ case LTTNG_ID_UNKNOWN:
+ ERR("Invalid state for tracker id");
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ /* Mi */
+ if (writer) {
+ ret = mi_lttng_id_target(
+ writer, tracker_type, id, 0);
+ if (ret) {
+ goto end;
+ }
+ }
+ }
+ _MSG(" ]\n\n");
+
+ /* Mi close tracker_id and targets */
+ if (writer) {
+ ret = mi_lttng_close_multi_element(writer, 2);
+ if (ret) {
+ goto end;
+ }
+ }
+ }
+end:
+ lttng_tracker_ids_destroy(ids);
+ return ret;
+}
+
+/*
+ * List all trackers of a domain
+ */
+static int list_trackers(const struct lttng_domain *domain)
+{
+ int ret = 0;
+
+ /* Trackers listing */
+ if (lttng_opt_mi) {
+ ret = mi_lttng_trackers_open(writer);
+ if (ret) {
+ goto end;
+ }
+ }
+
+ switch (domain->type) {
+ case LTTNG_DOMAIN_KERNEL:
+ /* pid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_PID);
+ if (ret) {
+ goto end;
+ }
+ /* vpid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_VPID);
+ if (ret) {
+ goto end;
+ }
+ /* uid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_UID);
+ if (ret) {
+ goto end;
+ }
+ /* vuid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_VUID);
+ if (ret) {
+ goto end;
+ }
+ /* gid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_GID);
+ if (ret) {
+ goto end;
+ }
+ /* vgid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_VGID);
+ if (ret) {
+ goto end;
+ }
+ break;
+ case LTTNG_DOMAIN_UST:
+ /* vpid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_VPID);
+ if (ret) {
+ goto end;
+ }
+ /* vuid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_VUID);
+ if (ret) {
+ goto end;
+ }
+ /* vgid tracker */
+ ret = list_tracker_ids(LTTNG_TRACKER_VGID);
+ if (ret) {
+ goto end;
+ }
+ break;
+ default:
+ break;
+ }
+ 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, 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;