#include <common/sessiond-comm/relayd.h>
#include <common/uri.h>
#include <common/utils.h>
+#include <common/path.h>
#include <common/align.h>
#include <common/ini-config/ini-config.h>
#include <common/dynamic-buffer.h>
* request.
*/
try_stream_close(stream);
- if (stream->is_metadata) {
- struct relay_viewer_stream *vstream;
-
- vstream = viewer_stream_get_by_id(stream->stream_handle);
- if (vstream) {
- if (stream->no_new_metadata_notified) {
- /*
- * Since all the metadata has been sent to the
- * viewer and that we have a request to close
- * its stream, we can safely teardown the
- * corresponding metadata viewer stream.
- */
- viewer_stream_put(vstream);
- }
- /* Put local reference. */
- viewer_stream_put(vstream);
- }
- }
stream_put(stream);
ret = 0;
return ret;
}
+static ssize_t relay_unpack_rotate_streams_header(
+ const struct lttng_buffer_view *payload,
+ struct lttcomm_relayd_rotate_streams *_rotate_streams)
+{
+ struct lttcomm_relayd_rotate_streams rotate_streams;
+ /*
+ * Set to the smallest version (packed) of `lttcomm_relayd_rotate_streams`.
+ * This is the smallest version of this structure, but it can be larger;
+ * this variable is updated once the proper size of the structure is known.
+ *
+ * See comment at the declaration of this structure for more information.
+ */
+ ssize_t header_len = sizeof(struct lttcomm_relayd_rotate_streams_packed);
+ size_t expected_payload_size_no_padding,
+ expected_payload_size_3_bytes_padding,
+ expected_payload_size_7_bytes_padding;
+
+ if (payload->size < header_len) {
+ ERR("Unexpected payload size in \"relay_rotate_session_stream\": expected >= %zu bytes, got %zu bytes",
+ header_len, payload->size);
+ goto error;
+ }
+
+ /*
+ * Some versions incorrectly omitted the LTTNG_PACKED annotation on the
+ * `new_chunk_id` optional field of struct lttcomm_relayd_rotate_streams.
+ *
+ * We start by "unpacking" `stream_count` to figure out the padding length
+ * emited by our peer.
+ */
+ memcpy(&rotate_streams.stream_count, payload->data,
+ sizeof(rotate_streams.stream_count));
+ rotate_streams = (typeof(rotate_streams)) {
+ .stream_count = be32toh(rotate_streams.stream_count),
+ };
+
+ /*
+ * Payload size expected given the possible padding lengths in
+ * `struct lttcomm_relayd_rotate_streams`.
+ */
+ expected_payload_size_no_padding = (rotate_streams.stream_count *
+ sizeof(*rotate_streams.rotation_positions)) +
+ sizeof(lttcomm_relayd_rotate_streams_packed);
+ expected_payload_size_3_bytes_padding = (rotate_streams.stream_count *
+ sizeof(*rotate_streams.rotation_positions)) +
+ sizeof(lttcomm_relayd_rotate_streams_3_bytes_padding);
+ expected_payload_size_7_bytes_padding = (rotate_streams.stream_count *
+ sizeof(*rotate_streams.rotation_positions)) +
+ sizeof(lttcomm_relayd_rotate_streams_7_bytes_padding);
+
+ if (payload->size == expected_payload_size_no_padding) {
+ struct lttcomm_relayd_rotate_streams_packed packed_rotate_streams;
+
+ /*
+ * This handles cases where someone might build with
+ * -fpack-struct or any other toolchain that wouldn't produce
+ * padding to align `value`.
+ */
+ DBG("Received `struct lttcomm_relayd_rotate_streams` with no padding");
+
+ header_len = sizeof(packed_rotate_streams);
+ memcpy(&packed_rotate_streams, payload->data, header_len);
+
+ /* Unpack the packed structure to the natively-packed version. */
+ *_rotate_streams = (typeof(*_rotate_streams)) {
+ .stream_count = be32toh(packed_rotate_streams.stream_count),
+ .new_chunk_id = (typeof(_rotate_streams->new_chunk_id)) {
+ .is_set = !!packed_rotate_streams.new_chunk_id.is_set,
+ .value = be64toh(packed_rotate_streams.new_chunk_id.value),
+ }
+ };
+ } else if (payload->size == expected_payload_size_3_bytes_padding) {
+ struct lttcomm_relayd_rotate_streams_3_bytes_padding padded_rotate_streams;
+
+ DBG("Received `struct lttcomm_relayd_rotate_streams` with 3 bytes of padding (4-byte aligned peer)");
+
+ header_len = sizeof(padded_rotate_streams);
+ memcpy(&padded_rotate_streams, payload->data, header_len);
+
+ /* Unpack the 3-byte padded structure to the natively-packed version. */
+ *_rotate_streams = (typeof(*_rotate_streams)) {
+ .stream_count = be32toh(padded_rotate_streams.stream_count),
+ .new_chunk_id = (typeof(_rotate_streams->new_chunk_id)) {
+ .is_set = !!padded_rotate_streams.new_chunk_id.is_set,
+ .value = be64toh(padded_rotate_streams.new_chunk_id.value),
+ }
+ };
+ } else if (payload->size == expected_payload_size_7_bytes_padding) {
+ struct lttcomm_relayd_rotate_streams_7_bytes_padding padded_rotate_streams;
+
+ DBG("Received `struct lttcomm_relayd_rotate_streams` with 7 bytes of padding (8-byte aligned peer)");
+
+ header_len = sizeof(padded_rotate_streams);
+ memcpy(&padded_rotate_streams, payload->data, header_len);
+
+ /* Unpack the 7-byte padded structure to the natively-packed version. */
+ *_rotate_streams = (typeof(*_rotate_streams)) {
+ .stream_count = be32toh(padded_rotate_streams.stream_count),
+ .new_chunk_id = (typeof(_rotate_streams->new_chunk_id)) {
+ .is_set = !!padded_rotate_streams.new_chunk_id.is_set,
+ .value = be64toh(padded_rotate_streams.new_chunk_id.value),
+ }
+ };
+
+ header_len = sizeof(padded_rotate_streams);
+ } else {
+ ERR("Unexpected payload size in \"relay_rotate_session_stream\": expected %zu, %zu or %zu bytes, got %zu bytes",
+ expected_payload_size_no_padding,
+ expected_payload_size_3_bytes_padding,
+ expected_payload_size_7_bytes_padding,
+ payload->size);
+ goto error;
+ }
+
+ return header_len;
+error:
+ return -1;
+}
+
/*
* relay_rotate_session_stream: rotate a stream to a new tracefile for the
* session rotation feature (not the tracefile rotation feature).
struct lttcomm_relayd_rotate_streams rotate_streams;
struct lttcomm_relayd_generic_reply reply = {};
struct relay_stream *stream = NULL;
- const size_t header_len = sizeof(struct lttcomm_relayd_rotate_streams);
struct lttng_trace_chunk *next_trace_chunk = NULL;
struct lttng_buffer_view stream_positions;
char chunk_id_buf[MAX_INT_DEC_LEN(uint64_t)];
const char *chunk_id_str = "none";
+ ssize_t header_len;
if (!session || !conn->version_check_done) {
ERR("Trying to rotate a stream before version check");
goto end_no_reply;
}
- if (payload->size < header_len) {
- ERR("Unexpected payload size in \"relay_rotate_session_stream\": expected >= %zu bytes, got %zu bytes",
- header_len, payload->size);
+ header_len = relay_unpack_rotate_streams_header(payload, &rotate_streams);
+ if (header_len < 0) {
ret = -1;
goto end_no_reply;
}
- memcpy(&rotate_streams, payload->data, header_len);
-
- /* Convert header to host endianness. */
- rotate_streams = (typeof(rotate_streams)) {
- .stream_count = be32toh(rotate_streams.stream_count),
- .new_chunk_id = (typeof(rotate_streams.new_chunk_id)) {
- .is_set = !!rotate_streams.new_chunk_id.is_set,
- .value = be64toh(rotate_streams.new_chunk_id.value),
- }
- };
-
if (rotate_streams.new_chunk_id.is_set) {
/*
* Retrieve the trace chunk the stream must transition to. As
*/
next_trace_chunk = sessiond_trace_chunk_registry_get_chunk(
sessiond_trace_chunk_registry,
- session->sessiond_uuid, session->id,
+ session->sessiond_uuid,
+ conn->session->id_sessiond.is_set ?
+ conn->session->id_sessiond.value :
+ conn->session->id,
rotate_streams.new_chunk_id.value);
if (!next_trace_chunk) {
char uuid_str[LTTNG_UUID_STR_LEN];
chunk_id_str);
stream_positions = lttng_buffer_view_from_view(payload,
- sizeof(rotate_streams), -1);
+ header_len, -1);
if (!stream_positions.data ||
stream_positions.size <
(rotate_streams.stream_count *
return ret;
}
-
-
/*
* relay_create_trace_chunk: create a new trace chunk
*/
msg->creation_timestamp = be64toh(msg->creation_timestamp);
msg->override_name_length = be32toh(msg->override_name_length);
+ pthread_mutex_lock(&conn->session->lock);
+ session->ongoing_rotation = true;
if (session->current_trace_chunk &&
!lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) {
chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk,
goto end;
}
}
- session->ongoing_rotation = true;
if (!session->current_trace_chunk) {
if (!session->has_rotated) {
new_path = "";
published_chunk = sessiond_trace_chunk_registry_publish_chunk(
sessiond_trace_chunk_registry,
conn->session->sessiond_uuid,
- conn->session->id,
+ conn->session->id_sessiond.is_set ?
+ conn->session->id_sessiond.value :
+ conn->session->id,
chunk);
if (!published_chunk) {
char uuid_str[LTTNG_UUID_STR_LEN];
goto end;
}
- pthread_mutex_lock(&conn->session->lock);
if (conn->session->pending_closure_trace_chunk) {
/*
* Invalid; this means a second create_trace_chunk command was
ERR("Invalid trace chunk close command received; a trace chunk is already waiting for a trace chunk close command");
reply_code = LTTNG_ERR_INVALID_PROTOCOL;
ret = -1;
- goto end_unlock_session;
+ goto end;
}
conn->session->pending_closure_trace_chunk =
conn->session->current_trace_chunk;
if (!conn->session->pending_closure_trace_chunk) {
session->ongoing_rotation = false;
}
-end_unlock_session:
- pthread_mutex_unlock(&conn->session->lock);
end:
+ pthread_mutex_unlock(&conn->session->lock);
reply.ret_code = htobe32((uint32_t) reply_code);
send_ret = conn->sock->ops->sendmsg(conn->sock,
&reply,
chunk = sessiond_trace_chunk_registry_get_chunk(
sessiond_trace_chunk_registry,
conn->session->sessiond_uuid,
- conn->session->id,
+ conn->session->id_sessiond.is_set ?
+ conn->session->id_sessiond.value :
+ conn->session->id,
chunk_id);
if (!chunk) {
char uuid_str[LTTNG_UUID_STR_LEN];
return ret;
}
-#define DBG_CMD(cmd_name, conn) \
- DBG3("Processing \"%s\" command for socket %i", cmd_name, conn->sock->fd);
-
static int relay_process_control_command(struct relay_connection *conn,
const struct lttcomm_relayd_hdr *header,
const struct lttng_buffer_view *payload)
{
int ret = 0;
+ DBG3("Processing \"%s\" command for socket %i",
+ lttcomm_relayd_command_str((lttcomm_relayd_command) header->cmd),
+ conn->sock->fd);
switch (header->cmd) {
case RELAYD_CREATE_SESSION:
- DBG_CMD("RELAYD_CREATE_SESSION", conn);
ret = relay_create_session(header, conn, payload);
break;
case RELAYD_ADD_STREAM:
- DBG_CMD("RELAYD_ADD_STREAM", conn);
ret = relay_add_stream(header, conn, payload);
break;
case RELAYD_START_DATA:
- DBG_CMD("RELAYD_START_DATA", conn);
ret = relay_start(header, conn, payload);
break;
case RELAYD_SEND_METADATA:
- DBG_CMD("RELAYD_SEND_METADATA", conn);
ret = relay_recv_metadata(header, conn, payload);
break;
case RELAYD_VERSION:
- DBG_CMD("RELAYD_VERSION", conn);
ret = relay_send_version(header, conn, payload);
break;
case RELAYD_CLOSE_STREAM:
- DBG_CMD("RELAYD_CLOSE_STREAM", conn);
ret = relay_close_stream(header, conn, payload);
break;
case RELAYD_DATA_PENDING:
- DBG_CMD("RELAYD_DATA_PENDING", conn);
ret = relay_data_pending(header, conn, payload);
break;
case RELAYD_QUIESCENT_CONTROL:
- DBG_CMD("RELAYD_QUIESCENT_CONTROL", conn);
ret = relay_quiescent_control(header, conn, payload);
break;
case RELAYD_BEGIN_DATA_PENDING:
- DBG_CMD("RELAYD_BEGIN_DATA_PENDING", conn);
ret = relay_begin_data_pending(header, conn, payload);
break;
case RELAYD_END_DATA_PENDING:
- DBG_CMD("RELAYD_END_DATA_PENDING", conn);
ret = relay_end_data_pending(header, conn, payload);
break;
case RELAYD_SEND_INDEX:
- DBG_CMD("RELAYD_SEND_INDEX", conn);
ret = relay_recv_index(header, conn, payload);
break;
case RELAYD_STREAMS_SENT:
- DBG_CMD("RELAYD_STREAMS_SENT", conn);
ret = relay_streams_sent(header, conn, payload);
break;
case RELAYD_RESET_METADATA:
- DBG_CMD("RELAYD_RESET_METADATA", conn);
ret = relay_reset_metadata(header, conn, payload);
break;
case RELAYD_ROTATE_STREAMS:
- DBG_CMD("RELAYD_ROTATE_STREAMS", conn);
ret = relay_rotate_session_streams(header, conn, payload);
break;
case RELAYD_CREATE_TRACE_CHUNK:
- DBG_CMD("RELAYD_CREATE_TRACE_CHUNK", conn);
ret = relay_create_trace_chunk(header, conn, payload);
break;
case RELAYD_CLOSE_TRACE_CHUNK:
- DBG_CMD("RELAYD_CLOSE_TRACE_CHUNK", conn);
ret = relay_close_trace_chunk(header, conn, payload);
break;
case RELAYD_TRACE_CHUNK_EXISTS:
- DBG_CMD("RELAYD_TRACE_CHUNK_EXISTS", conn);
ret = relay_trace_chunk_exists(header, conn, payload);
break;
case RELAYD_GET_CONFIGURATION:
- DBG_CMD("RELAYD_GET_CONFIGURATION", conn);
ret = relay_get_configuration(header, conn, payload);
break;
case RELAYD_UPDATE_SYNC_INFO:
reception_buffer->data + state->received,
state->left_to_receive, MSG_DONTWAIT);
if (ret < 0) {
+ DIAGNOSTIC_PUSH
+ DIAGNOSTIC_IGNORE_LOGICAL_OP
if (errno != EAGAIN && errno != EWOULDBLOCK) {
+ DIAGNOSTIC_POP
PERROR("Unable to receive command payload on sock %d",
conn->sock->fd);
status = RELAY_CONNECTION_STATUS_ERROR;
reception_buffer->data + state->received,
state->left_to_receive, MSG_DONTWAIT);
if (ret < 0) {
+ DIAGNOSTIC_PUSH
+ DIAGNOSTIC_IGNORE_LOGICAL_OP
if (errno != EAGAIN && errno != EWOULDBLOCK) {
+ DIAGNOSTIC_POP
PERROR("Unable to receive control command header on sock %d",
conn->sock->fd);
status = RELAY_CONNECTION_STATUS_ERROR;
memcpy(&conn->protocol.ctrl.state.receive_payload.header,
&header, sizeof(header));
- DBG("Done receiving control command header: fd = %i, cmd = %" PRIu32 ", cmd_version = %" PRIu32 ", payload size = %" PRIu64 " bytes",
- conn->sock->fd, header.cmd, header.cmd_version,
- header.data_size);
+ DBG("Done receiving control command header: fd = %i, cmd = %s, cmd_version = %" PRIu32 ", payload size = %" PRIu64 " bytes",
+ conn->sock->fd, lttcomm_relayd_command_str((enum lttcomm_relayd_command) header.cmd),
+ header.cmd_version, header.data_size);
if (header.data_size > DEFAULT_NETWORK_RELAYD_CTRL_MAX_PAYLOAD_SIZE) {
ERR("Command header indicates a payload (%" PRIu64 " bytes) that exceeds the maximal payload size allowed on a control connection.",
state->header_reception_buffer + state->received,
state->left_to_receive, MSG_DONTWAIT);
if (ret < 0) {
+ DIAGNOSTIC_PUSH
+ DIAGNOSTIC_IGNORE_LOGICAL_OP
if (errno != EAGAIN && errno != EWOULDBLOCK) {
+ DIAGNOSTIC_POP
PERROR("Unable to receive data header on sock %d", conn->sock->fd);
status = RELAY_CONNECTION_STATUS_ERROR;
}
ret = conn->sock->ops->recvmsg(conn->sock, data_buffer,
recv_size, MSG_DONTWAIT);
if (ret < 0) {
+ DIAGNOSTIC_PUSH
+ DIAGNOSTIC_IGNORE_LOGICAL_OP
if (errno != EAGAIN && errno != EWOULDBLOCK) {
+ DIAGNOSTIC_POP
PERROR("Socket %d error", conn->sock->fd);
status = RELAY_CONNECTION_STATUS_ERROR;
}