return ret;
}
+/*
+ * Get run-time attributes if the session has been started (discarded events,
+ * lost packets).
+ */
+static int get_kernel_runtime_stats(struct ltt_session *session,
+ struct ltt_kernel_channel *kchan, uint64_t *discarded_events,
+ uint64_t *lost_packets)
+{
+ int ret;
+
+ if (!session->has_been_started) {
+ ret = 0;
+ *discarded_events = 0;
+ *lost_packets = 0;
+ goto end;
+ }
+
+ ret = consumer_get_discarded_events(session->id, kchan->fd,
+ session->kernel_session->consumer,
+ discarded_events);
+ if (ret < 0) {
+ goto end;
+ }
+
+ ret = consumer_get_lost_packets(session->id, kchan->fd,
+ session->kernel_session->consumer,
+ lost_packets);
+ if (ret < 0) {
+ goto end;
+ }
+
+end:
+ return ret;
+}
+
+/*
+ * Get run-time attributes if the session has been started (discarded events,
+ * lost packets).
+ */
+static int get_ust_runtime_stats(struct ltt_session *session,
+ struct ltt_ust_channel *uchan, uint64_t *discarded_events,
+ uint64_t *lost_packets)
+{
+ int ret;
+ struct ltt_ust_session *usess;
+
+ usess = session->ust_session;
+
+ if (!usess || !session->has_been_started) {
+ *discarded_events = 0;
+ *lost_packets = 0;
+ ret = 0;
+ goto end;
+ }
+
+ if (usess->buffer_type == LTTNG_BUFFER_PER_UID) {
+ ret = ust_app_uid_get_channel_runtime_stats(usess->id,
+ &usess->buffer_reg_uid_list,
+ usess->consumer, uchan->id,
+ uchan->attr.overwrite,
+ discarded_events,
+ lost_packets);
+ } else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) {
+ ret = ust_app_pid_get_channel_runtime_stats(usess,
+ uchan, usess->consumer,
+ uchan->attr.overwrite,
+ discarded_events,
+ lost_packets);
+ if (ret < 0) {
+ goto end;
+ }
+ *discarded_events += uchan->per_pid_closed_app_discarded;
+ *lost_packets += uchan->per_pid_closed_app_lost;
+ } else {
+ ERR("Unsupported buffer type");
+ ret = -1;
+ goto end;
+ }
+
+end:
+ return ret;
+}
+
/*
* Fill lttng_channel array of all channels.
*/
static void list_lttng_channels(enum lttng_domain_type domain,
- struct ltt_session *session, struct lttng_channel *channels)
+ struct ltt_session *session, struct lttng_channel *channels,
+ struct lttcomm_channel_extended *chan_exts)
{
- int i = 0;
+ int i = 0, ret;
struct ltt_kernel_channel *kchan;
DBG("Listing channels for session %s", session->name);
if (session->kernel_session != NULL) {
cds_list_for_each_entry(kchan,
&session->kernel_session->channel_list.head, list) {
+ uint64_t discarded_events, lost_packets;
+
+ ret = get_kernel_runtime_stats(session, kchan,
+ &discarded_events, &lost_packets);
+ if (ret < 0) {
+ goto end;
+ }
/* Copy lttng_channel struct to array */
memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
channels[i].enabled = kchan->enabled;
+ chan_exts[i].discarded_events =
+ discarded_events;
+ chan_exts[i].lost_packets = lost_packets;
i++;
}
}
rcu_read_lock();
cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
&iter.iter, uchan, node.node) {
+ uint64_t discarded_events, lost_packets;
+
strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN);
channels[i].attr.overwrite = uchan->attr.overwrite;
channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
channels[i].enabled = uchan->enabled;
channels[i].attr.tracefile_size = uchan->tracefile_size;
channels[i].attr.tracefile_count = uchan->tracefile_count;
+
+ /*
+ * Map enum lttng_ust_output to enum lttng_event_output.
+ */
switch (uchan->attr.output) {
case LTTNG_UST_MMAP:
- default:
channels[i].attr.output = LTTNG_EVENT_MMAP;
break;
+ default:
+ /*
+ * LTTNG_UST_MMAP is the only supported UST
+ * output mode.
+ */
+ assert(0);
+ break;
}
+
+ ret = get_ust_runtime_stats(session, uchan,
+ &discarded_events, &lost_packets);
+ if (ret < 0) {
+ break;
+ }
+ chan_exts[i].discarded_events = discarded_events;
+ chan_exts[i].lost_packets = lost_packets;
i++;
}
rcu_read_unlock();
default:
break;
}
+
+end:
+ return;
}
static void increment_extended_len(const char *filter_expression,
if (nb_event == 0) {
*total_size = 0;
*events = NULL;
- goto syscall;
+ goto end;
}
/* Compute required extended infos size */
goto error;
}
- extended_at = ((uint8_t *) events) +
+ extended_at = ((void *) *events) +
nb_event * sizeof(struct lttng_event);
/* Kernel channels */
&extended_at);
}
-syscall:
- if (syscall_table) {
- ssize_t new_size;
-
- new_size = syscall_list_channel(kchan, events, nb_event);
- if (new_size < 0) {
- free(events);
- ret = -new_size;
- goto error;
- }
- nb_event = new_size;
- }
-
+end:
return nb_event;
error:
* Else, it's stays untouched and a lttcomm error code is returned.
*/
static int create_connect_relayd(struct lttng_uri *uri,
- struct lttcomm_relayd_sock **relayd_sock)
+ struct lttcomm_relayd_sock **relayd_sock,
+ struct consumer_output *consumer)
{
int ret;
struct lttcomm_relayd_sock *rsock;
ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
goto close_sock;
}
+ consumer->relay_major_version = rsock->major;
+ consumer->relay_minor_version = rsock->minor;
} else if (uri->stype == LTTNG_STREAM_DATA) {
DBG3("Creating relayd data socket from URI");
} else {
struct lttcomm_relayd_sock *rsock = NULL;
/* Connect to relayd and make version check if uri is the control. */
- ret = create_connect_relayd(relayd_uri, &rsock);
+ ret = create_connect_relayd(relayd_uri, &rsock, consumer);
if (ret != LTTNG_OK) {
goto error;
}
/* Session is now ready for network streaming. */
session->net_handle = 1;
}
+ session->consumer->relay_major_version =
+ usess->consumer->relay_major_version;
+ session->consumer->relay_minor_version =
+ usess->consumer->relay_minor_version;
}
if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
/* Session is now ready for network streaming. */
session->net_handle = 1;
}
+ session->consumer->relay_major_version =
+ ksess->consumer->relay_major_version;
+ session->consumer->relay_minor_version =
+ ksess->consumer->relay_minor_version;
}
error:
ssize_t cmd_list_channels(enum lttng_domain_type domain,
struct ltt_session *session, struct lttng_channel **channels)
{
- int ret;
- ssize_t nb_chan = 0;
+ ssize_t nb_chan = 0, payload_size = 0, ret;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
}
DBG3("Number of kernel channels %zd", nb_chan);
if (nb_chan <= 0) {
- ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
+ ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND;
+ goto end;
}
break;
case LTTNG_DOMAIN_UST:
}
DBG3("Number of UST global channels %zd", nb_chan);
if (nb_chan < 0) {
- ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
- goto error;
+ ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND;
+ goto end;
}
break;
default:
- ret = LTTNG_ERR_UND;
- goto error;
+ ret = -LTTNG_ERR_UND;
+ goto end;
}
if (nb_chan > 0) {
- *channels = zmalloc(nb_chan * sizeof(struct lttng_channel));
+ const size_t channel_size = sizeof(struct lttng_channel) +
+ sizeof(struct lttcomm_channel_extended);
+ struct lttcomm_channel_extended *channel_exts;
+
+ payload_size = nb_chan * channel_size;
+ *channels = zmalloc(payload_size);
if (*channels == NULL) {
- ret = LTTNG_ERR_FATAL;
- goto error;
+ ret = -LTTNG_ERR_FATAL;
+ goto end;
}
- list_lttng_channels(domain, session, *channels);
+ channel_exts = ((void *) *channels) +
+ (nb_chan * sizeof(struct lttng_channel));
+ list_lttng_channels(domain, session, *channels, channel_exts);
+ } else {
+ *channels = NULL;
}
- return nb_chan;
-
-error:
- /* Return negative value to differentiate return code */
- return -ret;
+ ret = payload_size;
+end:
+ return ret;
}
/*