From 070b6a86970c981e8f79cbd3dc199008b25cc0dc Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Sun, 18 Aug 2019 14:53:33 -0400 Subject: [PATCH] Fix: streaming and snapshot backward compat for relayd < 2.11 MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Fix backward compatibility of session daemon 2.11 with relayd versions prior to 2.11. Session daemon and consumer daemon 2.11 use the "chunk" object to represent the current output directory. However, both sessiond and consumerd need to ensure they do not send chunk and rotation commands to a relayd older than 2.11, and tweak the stream paths accordingly. Signed-off-by: Mathieu Desnoyers Signed-off-by: Jérémie Galarneau --- src/bin/lttng-sessiond/cmd.c | 8 +++---- src/bin/lttng-sessiond/session.c | 19 ---------------- src/common/relayd/relayd.c | 39 +++++++++++++++++++++++++++++--- 3 files changed, 39 insertions(+), 27 deletions(-) diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 577647a1c..4447747de 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -2588,8 +2588,7 @@ int cmd_start_trace(struct ltt_session *session) goto error; } - if (session->output_traces && !session->current_trace_chunk && - session_output_supports_trace_chunks(session)) { + if (session->output_traces && !session->current_trace_chunk) { struct lttng_trace_chunk *trace_chunk; trace_chunk = session_create_new_trace_chunk( @@ -3199,8 +3198,7 @@ int cmd_destroy_session(struct ltt_session *session, if (reply_context) { reply_context->implicit_rotation_on_destroy = true; } - } else if (session->has_been_started && session->current_trace_chunk && - session_output_supports_trace_chunks(session)) { + } else if (session->has_been_started && session->current_trace_chunk) { /* * The user has not triggered a session rotation. However, to * ensure all data has been consumed, the session is rotated @@ -4787,7 +4785,7 @@ int cmd_rotate_session(struct ltt_session *session, } /* Unsupported feature in lttng-relayd before 2.11. */ - if (session->consumer->type == CONSUMER_DST_NET && + if (!quiet_rotation && session->consumer->type == CONSUMER_DST_NET && (session->consumer->relay_major_version == 2 && session->consumer->relay_minor_version < 11)) { cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY; diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 602059424..7fba07bb4 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -565,25 +565,6 @@ error: goto end_no_move; } -bool session_output_supports_trace_chunks(const struct ltt_session *session) -{ - const struct consumer_output *output = session->kernel_session ? - session->kernel_session->consumer : - session->ust_session->consumer; - - if (output->type == CONSUMER_DST_LOCAL) { - return true; - } else { - if (output->relay_major_version > 2) { - return true; - } else if (output->relay_major_version == 2 && - output->relay_minor_version >= 11) { - return true; - } - } - return false; -} - struct lttng_trace_chunk *session_create_new_trace_chunk( const struct ltt_session *session, const struct consumer_output *consumer_output_override, diff --git a/src/common/relayd/relayd.c b/src/common/relayd/relayd.c index ed5e45607..8e6b71173 100644 --- a/src/common/relayd/relayd.c +++ b/src/common/relayd/relayd.c @@ -34,6 +34,17 @@ #include "relayd.h" +static +bool relayd_supports_chunks(const struct lttcomm_relayd_sock *sock) +{ + if (sock->major > 2) { + return true; + } else if (sock->major == 2 && sock->minor >= 11) { + return true; + } + return false; +} + /* * Send command. Fill up the header and append the data. */ @@ -442,6 +453,10 @@ error: /* * Add stream on the relayd and assign stream handle to the stream_id argument. * + * Chunks are not supported by relayd prior to 2.11, but are used to + * internally between session daemon and consumer daemon to keep track + * of the channel and stream output path. + * * On success return 0 else return ret_code negative value. */ int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_name, @@ -456,25 +471,23 @@ int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_nam assert(rsock); assert(channel_name); assert(pathname); + assert(trace_chunk); DBG("Relayd adding stream for channel name %s", channel_name); /* Compat with relayd 2.1 */ if (rsock->minor == 1) { /* For 2.1 */ - assert(!trace_chunk); ret = relayd_add_stream_2_1(rsock, channel_name, pathname); } else if (rsock->minor > 1 && rsock->minor < 11) { /* From 2.2 to 2.10 */ - assert(!trace_chunk); ret = relayd_add_stream_2_2(rsock, channel_name, pathname, tracefile_size, tracefile_count); } else { enum lttng_trace_chunk_status chunk_status; uint64_t chunk_id; - assert(trace_chunk); chunk_status = lttng_trace_chunk_get_id(trace_chunk, &chunk_id); assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); @@ -1157,6 +1170,11 @@ int relayd_rotate_streams(struct lttcomm_relayd_sock *sock, char new_chunk_id_buf[MAX_INT_DEC_LEN(*new_chunk_id)] = {}; const char *new_chunk_id_str; + if (!relayd_supports_chunks(sock)) { + DBG("Refusing to rotate remote streams: relayd does not support chunks"); + return 0; + } + lttng_dynamic_buffer_init(&payload); /* Code flow error. Safety net. */ @@ -1249,6 +1267,11 @@ int relayd_create_trace_chunk(struct lttcomm_relayd_sock *sock, lttng_dynamic_buffer_init(&payload); + if (!relayd_supports_chunks(sock)) { + DBG("Refusing to create remote trace chunk: relayd does not support chunks"); + goto end; + } + status = lttng_trace_chunk_get_id(chunk, &chunk_id); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ret = -1; @@ -1329,6 +1352,11 @@ int relayd_close_trace_chunk(struct lttcomm_relayd_sock *sock, time_t close_timestamp; LTTNG_OPTIONAL(enum lttng_trace_chunk_command_type) close_command = {}; + if (!relayd_supports_chunks(sock)) { + DBG("Refusing to close remote trace chunk: relayd does not support chunks"); + goto end; + } + status = lttng_trace_chunk_get_id(chunk, &chunk_id); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ERR("Failed to get trace chunk id"); @@ -1400,6 +1428,11 @@ int relayd_trace_chunk_exists(struct lttcomm_relayd_sock *sock, struct lttcomm_relayd_trace_chunk_exists msg = {}; struct lttcomm_relayd_trace_chunk_exists_reply reply = {}; + if (!relayd_supports_chunks(sock)) { + DBG("Refusing to check for trace chunk existence: relayd does not support chunks"); + goto end; + } + msg = (typeof(msg)){ .chunk_id = htobe64(chunk_id), }; -- 2.34.1