return status;
}
+static bool is_trace_format_configuration_supported(
+ uint64_t supported_trace_format, lttng::trace_format_descriptor& trace_format)
+{
+ static const std::unordered_map<enum lttng_trace_format_descriptor_type,
+ enum lttcomm_relayd_configuration_trace_format_flag>
+ mapping = {
+ {LTTNG_TRACE_FORMAT_DESCRIPTOR_TYPE_CTF_1,
+ LTTCOMM_RELAYD_CONFIGURATION_TRACE_FORMAT_SUPPORTED_CTF1},
+ {LTTNG_TRACE_FORMAT_DESCRIPTOR_TYPE_CTF_2,
+ LTTCOMM_RELAYD_CONFIGURATION_TRACE_FORMAT_SUPPORTED_CTF2},
+ };
+
+ auto it = mapping.find(trace_format.type());
+ if (it == mapping.end()) {
+ return false;
+ }
+
+ if (!(supported_trace_format & it->second)) {
+ return false;
+ }
+
+ return true;
+}
+
/*
* Send both relayd sockets to a specific consumer and domain. This is a
* helper function to facilitate sending the information to the consumer for a
*
* Returns LTTNG_OK, or an LTTng error code on failure.
*/
-static enum lttng_error_code send_consumer_relayd_sockets(
- unsigned int session_id, struct consumer_output *consumer,
- struct consumer_socket *sock, const char *session_name,
- const char *hostname, const char *base_path, int session_live_timer,
- const uint64_t *current_chunk_id, time_t session_creation_time,
- bool session_name_contains_creation_time)
+static lttng_error_code send_consumer_relayd_sockets(const ltt_session& session,
+ struct consumer_output *consumer,
+ struct consumer_socket *sock,
+ const char *base_path,
+ const uint64_t *current_chunk_id)
{
enum lttng_error_code status = LTTNG_OK;
struct lttcomm_relayd_sock *control_sock = nullptr;
if (!sock->control_sock_sent) {
int ret;
uint64_t result_flags = 0;
+ uint64_t supported_trace_format = 0;
/* Connect to relayd and make version check if uri is the control. */
status = create_connect_relayd(&consumer->dst.net.control, &control_sock);
if (status != LTTNG_OK) {
consumer->relay_major_version = control_sock->major;
consumer->relay_minor_version = control_sock->minor;
- ret = relayd_get_configuration(control_sock, 0, &result_flags);
+ ret = relayd_get_configuration(control_sock, 0, result_flags, nullptr);
if (ret < 0) {
ERR("Unable to get relayd configuration");
status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
consumer->relay_allows_clear = true;
}
- status = send_consumer_relayd_socket(session_id, &consumer->dst.net.control,
- consumer, sock, session_name, hostname, base_path,
- session_live_timer, current_chunk_id, session_creation_time,
- session_name_contains_creation_time, *control_sock);
+ if (!is_trace_format_configuration_supported(
+ supported_trace_format, *session.trace_format)) {
+ ERR("Relayd does not support the requested trace format");
+ status = LTTNG_ERR_TRACE_FORMAT_UNSUPPORTED_RELAY_DAEMON;
+ goto error;
+ }
+
+ status = send_consumer_relayd_socket(session.id, &consumer->dst.net.control,
+ consumer, sock, session.name, session.hostname, base_path,
+ session.live_timer, current_chunk_id, session.creation_time,
+ session.name_contains_creation_time, *control_sock);
if (status != LTTNG_OK) {
goto error;
}
LTTNG_ASSERT(data_sock);
- status = send_consumer_relayd_socket(session_id, &consumer->dst.net.data, consumer,
- sock, session_name, hostname, base_path, session_live_timer,
- current_chunk_id, session_creation_time,
- session_name_contains_creation_time, *data_sock);
+ status = send_consumer_relayd_socket(session.id, &consumer->dst.net.data, consumer,
+ sock, session.name, session.hostname, base_path, session.live_timer,
+ current_chunk_id, session.creation_time,
+ session.name_contains_creation_time, *data_sock);
if (status != LTTNG_OK) {
goto error;
usess = session->ust_session;
ksess = session->kernel_session;
- ERR("Setting relayd for session %s", session->name);
+ DBG("Setting relayd for session %s", session->name);
rcu_read_lock();
if (session->current_trace_chunk) {
if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
&& usess->consumer->enabled) {
/* For each consumer socket, send relayd sockets */
- cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
- socket, node.node) {
+ cds_lfht_for_each_entry (
+ usess->consumer->socks->ht, &iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = send_consumer_relayd_sockets(session->id,
- usess->consumer, socket,
- session->name, session->hostname,
+ ret = send_consumer_relayd_sockets(*session, usess->consumer, socket,
session->base_path,
- session->live_timer,
- current_chunk_id.is_set ? ¤t_chunk_id.value : NULL,
- session->creation_time,
- session->name_contains_creation_time);
+ current_chunk_id.is_set ? ¤t_chunk_id.value : NULL);
pthread_mutex_unlock(socket->lock);
if (ret != LTTNG_OK) {
goto error;
if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
&& ksess->consumer->enabled) {
- cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
- socket, node.node) {
+ cds_lfht_for_each_entry (
+ ksess->consumer->socks->ht, &iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = send_consumer_relayd_sockets(session->id,
- ksess->consumer, socket,
- session->name, session->hostname,
+ ret = send_consumer_relayd_sockets(*session, ksess->consumer, socket,
session->base_path,
- session->live_timer,
- current_chunk_id.is_set ? ¤t_chunk_id.value : NULL,
- session->creation_time,
- session->name_contains_creation_time);
+ current_chunk_id.is_set ? ¤t_chunk_id.value : NULL);
pthread_mutex_unlock(socket->lock);
if (ret != LTTNG_OK) {
goto error;
cds_list_for_each_entry(session, &list->head, list) {
struct lttng_session tmp_session = {};
struct lttng_session_extended tmp_extended = {};
+ struct lttng_payload trace_format_buffer;
+ lttng_payload_init(&trace_format_buffer);
tmp_session.extended.ptr = &tmp_extended;
if (!session_get(session)) {
+ lttng_payload_reset(&trace_format_buffer);
continue;
}
/*
if (!session_access_ok(session, uid) ||
session->destroyed) {
session_put(session);
+ lttng_payload_reset(&trace_format_buffer);
continue;
}
continue;
}
+ session->trace_format->serialize(&trace_format_buffer);
+
strncpy(tmp_session.name, session->name, NAME_MAX);
tmp_session.name[NAME_MAX - 1] = '\0';
tmp_session.enabled = session->active;
tmp_session.snapshot_mode = session->snapshot_mode;
tmp_session.live_timer_interval = session->live_timer;
LTTNG_OPTIONAL_SET(&tmp_extended.creation_time, (uint64_t) session->creation_time);
+ tmp_extended.serialized_trace_format_descriptor =
+ lttng_buffer_view_from_dynamic_buffer(&trace_format_buffer.buffer,
+ 0, trace_format_buffer.buffer.size);
ret = lttng_session_serialize(&tmp_session, reply_payload);
+ lttng_payload_reset(&trace_format_buffer);
if (ret) {
ret_code = LTTNG_ERR_FATAL;
goto error;
* snapshot output.
*/
rcu_read_lock();
- cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
- socket, node.node) {
+ cds_lfht_for_each_entry (output->socks->ht, &iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
- status = send_consumer_relayd_sockets(session->id,
- output, socket,
- session->name, session->hostname,
- base_path,
- session->live_timer,
- current_chunk_id.is_set ? ¤t_chunk_id.value : NULL,
- session->creation_time,
- session->name_contains_creation_time);
+ status = send_consumer_relayd_sockets(*session, output, socket, base_path,
+ current_chunk_id.is_set ? ¤t_chunk_id.value : NULL);
pthread_mutex_unlock(socket->lock);
if (status != LTTNG_OK) {
rcu_read_unlock();
projects / lttng-tools.git / blobdiff