+/*
+ * 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 ? : "<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;
+ }
+ }