X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fmain.c;h=6234e3e170d92515d1255a15087906531369083a;hp=1cbebdcf23ca4f9f901ea7855b3d3543fcc10da2;hb=6760999493e83d75539018eb9eed8f00f116ac12;hpb=70626904265631671312931f3e32d02583ce1e2e

diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c
index 1cbebdcf2..6234e3e17 100644
--- a/src/bin/lttng-relayd/main.c
+++ b/src/bin/lttng-relayd/main.c
@@ -34,12 +34,15 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <sys/resource.h>
 #include <inttypes.h>
 #include <urcu/futex.h>
 #include <urcu/uatomic.h>
 #include <urcu/rculist.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <strings.h>
+#include <ctype.h>
 
 #include <lttng/lttng.h>
 #include <common/common.h>
@@ -60,22 +63,26 @@
 #include <common/dynamic-buffer.h>
 #include <common/buffer-view.h>
 #include <common/string-utils/format.h>
+#include <common/fd-tracker/fd-tracker.h>
+#include <common/fd-tracker/utils.h>
 
+#include "backward-compatibility-group-by.h"
 #include "cmd.h"
+#include "connection.h"
 #include "ctf-trace.h"
+#include "health-relayd.h"
 #include "index.h"
-#include "utils.h"
-#include "lttng-relayd.h"
 #include "live.h"
-#include "health-relayd.h"
-#include "testpoint.h"
-#include "viewer-stream.h"
+#include "lttng-relayd.h"
 #include "session.h"
+#include "sessiond-trace-chunks.h"
 #include "stream.h"
-#include "connection.h"
-#include "tracefile-array.h"
 #include "tcp_keep_alive.h"
-#include "sessiond-trace-chunks.h"
+#include "testpoint.h"
+#include "tracefile-array.h"
+#include "utils.h"
+#include "version.h"
+#include "viewer-stream.h"
 
 static const char *help_msg =
 #ifdef LTTNG_EMBED_HELP
@@ -94,8 +101,9 @@ enum relay_connection_status {
 };
 
 /* command line options */
-char *opt_output_path;
-static int opt_daemon, opt_background;
+char *opt_output_path, *opt_working_directory;
+static int opt_daemon, opt_background, opt_print_version, opt_allow_clear = 1;
+enum relay_group_output_by opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_UNKNOWN;
 
 /*
  * We need to wait for listener and live listener threads, as well as
@@ -156,6 +164,9 @@ static uint64_t last_relay_stream_id;
  */
 static struct relay_conn_queue relay_conn_queue;
 
+/* Cap of file desriptors to be in simultaneous use by the relay daemon. */
+static unsigned int lttng_opt_fd_cap;
+
 /* Global relay stream hash table. */
 struct lttng_ht *relay_streams_ht;
 
@@ -170,6 +181,9 @@ struct health_app *health_relayd;
 
 struct sessiond_trace_chunk_registry *sessiond_trace_chunk_registry;
 
+/* Global fd tracker. */
+struct fd_tracker *the_fd_tracker;
+
 static struct option long_options[] = {
 	{ "control-port", 1, 0, 'C', },
 	{ "data-port", 1, 0, 'D', },
@@ -177,16 +191,38 @@ static struct option long_options[] = {
 	{ "daemonize", 0, 0, 'd', },
 	{ "background", 0, 0, 'b', },
 	{ "group", 1, 0, 'g', },
+	{ "fd-cap", 1, 0, '\0', },
 	{ "help", 0, 0, 'h', },
 	{ "output", 1, 0, 'o', },
 	{ "verbose", 0, 0, 'v', },
 	{ "config", 1, 0, 'f' },
 	{ "version", 0, 0, 'V' },
+	{ "working-directory", 1, 0, 'w', },
+	{ "group-output-by-session", 0, 0, 's', },
+	{ "group-output-by-host", 0, 0, 'p', },
+	{ "disallow-clear", 0, 0, 'x' },
 	{ NULL, 0, 0, 0, },
 };
 
 static const char *config_ignore_options[] = { "help", "config", "version" };
 
+static void print_version(void) {
+	fprintf(stdout, "%s\n", VERSION);
+}
+
+static void relayd_config_log(void)
+{
+	DBG("LTTng-relayd " VERSION " - " VERSION_NAME "%s%s",
+			GIT_VERSION[0] == '\0' ? "" : " - " GIT_VERSION,
+			EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " EXTRA_VERSION_NAME);
+	if (EXTRA_VERSION_DESCRIPTION[0] != '\0') {
+		DBG("LTTng-relayd extra version description:\n\t" EXTRA_VERSION_DESCRIPTION "\n");
+	}
+	if (EXTRA_VERSION_PATCHES[0] != '\0') {
+		DBG("LTTng-relayd extra patches:\n\t" EXTRA_VERSION_PATCHES "\n");
+	}
+}
+
 /*
  * Take an option from the getopt output and set it in the right variable to be
  * used later.
@@ -199,9 +235,34 @@ static int set_option(int opt, const char *arg, const char *optname)
 
 	switch (opt) {
 	case 0:
-		fprintf(stderr, "option %s", optname);
-		if (arg) {
-			fprintf(stderr, " with arg %s\n", arg);
+		if (!strcmp(optname, "fd-cap")) {
+			unsigned long v;
+
+			errno = 0;
+			v = strtoul(arg, NULL, 0);
+			if (errno != 0 || !isdigit(arg[0])) {
+				ERR("Wrong value in --fd-cap parameter: %s",
+						arg);
+				ret = -1;
+				goto end;
+			}
+			if (v < DEFAULT_RELAYD_MINIMAL_FD_CAP) {
+				ERR("File descriptor cap must be set to at least %d",
+						DEFAULT_RELAYD_MINIMAL_FD_CAP);
+			}
+			if (v >= UINT_MAX) {
+				ERR("File descriptor cap overflow in --fd-cap parameter: %s",
+						arg);
+				ret = -1;
+				goto end;
+			}
+			lttng_opt_fd_cap = (unsigned int) v;
+			DBG3("File descriptor cap set to %u", lttng_opt_fd_cap);
+		} else {
+			fprintf(stderr, "unknown option %s", optname);
+			if (arg) {
+				fprintf(stderr, " with arg %s\n", arg);
+			}
 		}
 		break;
 	case 'C':
@@ -277,8 +338,8 @@ static int set_option(int opt, const char *arg, const char *optname)
 		}
 		exit(EXIT_FAILURE);
 	case 'V':
-		fprintf(stdout, "%s\n", VERSION);
-		exit(EXIT_SUCCESS);
+		opt_print_version = 1;
+		break;
 	case 'o':
 		if (lttng_is_setuid_setgid()) {
 			WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
@@ -292,6 +353,20 @@ static int set_option(int opt, const char *arg, const char *optname)
 			}
 		}
 		break;
+	case 'w':
+		if (lttng_is_setuid_setgid()) {
+			WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
+				"-w, --working-directory");
+		} else {
+			ret = asprintf(&opt_working_directory, "%s", arg);
+			if (ret < 0) {
+				ret = -errno;
+				PERROR("asprintf opt_working_directory");
+				goto end;
+			}
+		}
+		break;
+
 	case 'v':
 		/* Verbose level can increase using multiple -v */
 		if (arg) {
@@ -303,6 +378,24 @@ static int set_option(int opt, const char *arg, const char *optname)
 			}
 		}
 		break;
+	case 's':
+		if (opt_group_output_by != RELAYD_GROUP_OUTPUT_BY_UNKNOWN) {
+			ERR("Cannot set --group-output-by-session, another --group-output-by argument is present");
+			exit(EXIT_FAILURE);
+		}
+		opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_SESSION;
+		break;
+	case 'p':
+		if (opt_group_output_by != RELAYD_GROUP_OUTPUT_BY_UNKNOWN) {
+			ERR("Cannot set --group-output-by-host, another --group-output-by argument is present");
+			exit(EXIT_FAILURE);
+		}
+		opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_HOST;
+		break;
+	case 'x':
+		/* Disallow clear */
+		opt_allow_clear = 0;
+		break;
 	default:
 		/* Unknown option or other error.
 		 * Error is printed by getopt, just return */
@@ -372,6 +465,23 @@ end:
 	return ret;
 }
 
+static int parse_env_options(void)
+{
+	int ret = 0;
+	char *value = NULL;
+
+	value = lttng_secure_getenv(DEFAULT_LTTNG_RELAYD_WORKING_DIRECTORY_ENV);
+	if (value) {
+		opt_working_directory = strdup(value);
+		if (!opt_working_directory) {
+			ERR("Failed to allocate working directory string (\"%s\")",
+					value);
+			ret = -1;
+		}
+	}
+	return ret;
+}
+
 static int set_options(int argc, char **argv)
 {
 	int c, ret = 0, option_index = 0, retval = 0;
@@ -489,6 +599,35 @@ static int set_options(int argc, char **argv)
 			goto exit;
 		}
 	}
+	if (lttng_opt_fd_cap == 0) {
+		int ret;
+		struct rlimit rlimit;
+
+		ret = getrlimit(RLIMIT_NOFILE, &rlimit);
+		if (ret) {
+			PERROR("Failed to get file descriptor limit");
+			retval = -1;
+		}
+
+		lttng_opt_fd_cap = rlimit.rlim_cur;
+	}
+
+	if (opt_group_output_by == RELAYD_GROUP_OUTPUT_BY_UNKNOWN) {
+		opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_HOST;
+	}
+	if (opt_allow_clear) {
+		/* Check if env variable exists. */
+		const char *value = lttng_secure_getenv(DEFAULT_LTTNG_RELAYD_DISALLOW_CLEAR_ENV);
+		if (value) {
+			ret = config_parse_value(value);
+			if (ret < 0) {
+				ERR("Invalid value for %s specified", DEFAULT_LTTNG_RELAYD_DISALLOW_CLEAR_ENV);
+				retval = -1;
+				goto exit;
+			}
+			opt_allow_clear = !ret;
+		}
+	}
 
 exit:
 	free(optstring);
@@ -497,13 +636,9 @@ exit:
 
 static void print_global_objects(void)
 {
-	rcu_register_thread();
-
 	print_viewer_streams();
 	print_relay_streams();
 	print_sessions();
-
-	rcu_unregister_thread();
 }
 
 /*
@@ -522,11 +657,25 @@ static void relayd_cleanup(void)
 	if (sessions_ht)
 		lttng_ht_destroy(sessions_ht);
 
-	/* free the dynamically allocated opt_output_path */
 	free(opt_output_path);
+	free(opt_working_directory);
 
+	if (health_relayd) {
+		health_app_destroy(health_relayd);
+	}
 	/* Close thread quit pipes */
-	utils_close_pipe(thread_quit_pipe);
+	utils_close_pipe(health_quit_pipe);
+	if (thread_quit_pipe[0] != -1) {
+		(void) fd_tracker_util_pipe_close(
+				the_fd_tracker, thread_quit_pipe);
+	}
+	if (sessiond_trace_chunk_registry) {
+		sessiond_trace_chunk_registry_destroy(
+				sessiond_trace_chunk_registry);
+	}
+	if (the_fd_tracker) {
+		fd_tracker_destroy(the_fd_tracker);
+	}
 
 	uri_free(control_uri);
 	uri_free(data_uri);
@@ -535,6 +684,7 @@ static void relayd_cleanup(void)
 	if (tracing_group_name_override) {
 		free((void *) tracing_group_name);
 	}
+	fd_tracker_log(the_fd_tracker);
 }
 
 /*
@@ -688,11 +838,8 @@ void lttng_relay_notify_ready(void)
  */
 static int init_thread_quit_pipe(void)
 {
-	int ret;
-
-	ret = utils_create_pipe_cloexec(thread_quit_pipe);
-
-	return ret;
+	return fd_tracker_util_pipe_open_cloexec(
+			the_fd_tracker, "Quit pipe", thread_quit_pipe);
 }
 
 /*
@@ -1068,16 +1215,21 @@ static int relay_create_session(const struct lttcomm_relayd_hdr *recv_hdr,
 	int ret = 0;
 	ssize_t send_ret;
 	struct relay_session *session = NULL;
-	struct lttcomm_relayd_status_session reply = {};
+	struct lttcomm_relayd_create_session_reply_2_11 reply = {};
 	char session_name[LTTNG_NAME_MAX] = {};
 	char hostname[LTTNG_HOST_NAME_MAX] = {};
 	uint32_t live_timer = 0;
 	bool snapshot = false;
+	bool session_name_contains_creation_timestamp = false;
 	/* Left nil for peers < 2.11. */
+	char base_path[LTTNG_PATH_MAX] = {};
 	lttng_uuid sessiond_uuid = {};
 	LTTNG_OPTIONAL(uint64_t) id_sessiond = {};
 	LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
 	LTTNG_OPTIONAL(time_t) creation_time = {};
+	struct lttng_dynamic_buffer reply_payload;
+
+	lttng_dynamic_buffer_init(&reply_payload);
 
 	if (conn->minor < 4) {
 		/* From 2.1 to 2.3 */
@@ -1094,9 +1246,10 @@ static int relay_create_session(const struct lttcomm_relayd_hdr *recv_hdr,
 
 		/* From 2.11 to ... */
 		ret = cmd_create_session_2_11(payload, session_name, hostname,
-				&live_timer, &snapshot, &id_sessiond_value,
+				base_path, &live_timer, &snapshot, &id_sessiond_value,
 				sessiond_uuid, &has_current_chunk,
-				&current_chunk_id_value, &creation_time_value);
+				&current_chunk_id_value, &creation_time_value,
+				&session_name_contains_creation_timestamp);
 		if (lttng_uuid_is_nil(sessiond_uuid)) {
 			/* The nil UUID is reserved for pre-2.11 clients. */
 			ERR("Illegal nil UUID announced by peer in create session command");
@@ -1115,12 +1268,13 @@ static int relay_create_session(const struct lttcomm_relayd_hdr *recv_hdr,
 		goto send_reply;
 	}
 
-	session = session_create(session_name, hostname, live_timer,
+	session = session_create(session_name, hostname, base_path, live_timer,
 			snapshot, sessiond_uuid,
 			id_sessiond.is_set ? &id_sessiond.value : NULL,
 			current_chunk_id.is_set ? &current_chunk_id.value : NULL,
 			creation_time.is_set ? &creation_time.value : NULL,
-			conn->major, conn->minor);
+			conn->major, conn->minor,
+			session_name_contains_creation_timestamp);
 	if (!session) {
 		ret = -1;
 		goto send_reply;
@@ -1129,24 +1283,59 @@ static int relay_create_session(const struct lttcomm_relayd_hdr *recv_hdr,
 	conn->session = session;
 	DBG("Created session %" PRIu64, session->id);
 
-	reply.session_id = htobe64(session->id);
+	reply.generic.session_id = htobe64(session->id);
 
 send_reply:
 	if (ret < 0) {
-		reply.ret_code = htobe32(LTTNG_ERR_FATAL);
+		reply.generic.ret_code = htobe32(LTTNG_ERR_FATAL);
 	} else {
-		reply.ret_code = htobe32(LTTNG_OK);
+		reply.generic.ret_code = htobe32(LTTNG_OK);
 	}
 
-	send_ret = conn->sock->ops->sendmsg(conn->sock, &reply, sizeof(reply), 0);
-	if (send_ret < (ssize_t) sizeof(reply)) {
-		ERR("Failed to send \"create session\" command reply (ret = %zd)",
-				send_ret);
+	if (conn->minor < 11) {
+		/* From 2.1 to 2.10 */
+		ret = lttng_dynamic_buffer_append(&reply_payload,
+				&reply.generic, sizeof(reply.generic));
+		if (ret) {
+			ERR("Failed to append \"create session\" command reply header to payload buffer");
+			ret = -1;
+			goto end;
+		}
+	} else {
+		const uint32_t output_path_length =
+				session ? strlen(session->output_path) + 1 : 0;
+
+		reply.output_path_length = htobe32(output_path_length);
+		ret = lttng_dynamic_buffer_append(
+				&reply_payload, &reply, sizeof(reply));
+		if (ret) {
+			ERR("Failed to append \"create session\" command reply header to payload buffer");
+			goto end;
+		}
+
+		if (output_path_length) {
+			ret = lttng_dynamic_buffer_append(&reply_payload,
+					session->output_path,
+					output_path_length);
+			if (ret) {
+				ERR("Failed to append \"create session\" command reply path to payload buffer");
+				goto end;
+			}
+		}
+	}
+
+	send_ret = conn->sock->ops->sendmsg(conn->sock, reply_payload.data,
+			reply_payload.size, 0);
+	if (send_ret < (ssize_t) reply_payload.size) {
+		ERR("Failed to send \"create session\" command reply of %zu bytes (ret = %zd)",
+				reply_payload.size, send_ret);
 		ret = -1;
 	}
+end:
 	if (ret < 0 && session) {
 		session_put(session);
 	}
+	lttng_dynamic_buffer_reset(&reply_payload);
 	return ret;
 }
 
@@ -1256,12 +1445,57 @@ static int relay_add_stream(const struct lttcomm_relayd_hdr *recv_hdr,
 		goto send_reply;
 	}
 
+	/*
+	 * Backward compatibility for --group-output-by-session.
+	 * Prior to lttng 2.11, the complete path is passed by the stream.
+	 * Starting at 2.11, lttng-relayd uses chunk. When dealing with producer
+	 * >=2.11 the chunk is responsible for the output path. When dealing
+	 * with producer < 2.11 the chunk output_path is the root output path
+	 * and the stream carries the complete path (path_name).
+	 * To support --group-output-by-session with older producer (<2.11), we
+	 * need to craft the path based on the stream path.
+	 */
+	if (opt_group_output_by == RELAYD_GROUP_OUTPUT_BY_SESSION) {
+		if (conn->minor < 4) {
+			/*
+			 * From 2.1 to 2.3, the session_name is not passed on
+			 * the RELAYD_CREATE_SESSION command. The session name
+			 * is necessary to detect the presence of a base_path
+			 * inside the stream path. Without it we cannot perform
+			 * a valid group-output-by-session transformation.
+			 */
+			WARN("Unable to perform a --group-by-session transformation for session %" PRIu64
+			     " for stream with path \"%s\" as it is produced by a peer using a protocol older than v2.4",
+					session->id, path_name);
+		} else if (conn->minor >= 4 && conn->minor < 11) {
+			char *group_by_session_path_name;
+
+			assert(session->session_name[0] != '\0');
+
+			group_by_session_path_name =
+					backward_compat_group_by_session(
+							path_name,
+							session->session_name);
+			if (!group_by_session_path_name) {
+				ERR("Failed to apply group by session to stream of session %" PRIu64,
+						session->id);
+				goto send_reply;
+			}
+
+			DBG("Transformed session path from \"%s\" to \"%s\" to honor per-session name grouping",
+					path_name, group_by_session_path_name);
+
+			free(path_name);
+			path_name = group_by_session_path_name;
+		}
+	}
+
 	trace = ctf_trace_get_by_path_or_create(session, path_name);
 	if (!trace) {
 		goto send_reply;
 	}
-	/* This stream here has one reference on the trace. */
 
+	/* This stream here has one reference on the trace. */
 	pthread_mutex_lock(&last_relay_stream_id_lock);
 	stream_handle = ++last_relay_stream_id;
 	pthread_mutex_unlock(&last_relay_stream_id_lock);
@@ -1361,7 +1595,7 @@ static int relay_close_stream(const struct lttcomm_relayd_hdr *recv_hdr,
 
 		vstream = viewer_stream_get_by_id(stream->stream_handle);
 		if (vstream) {
-			if (vstream->metadata_sent == stream->metadata_received) {
+			if (stream->no_new_metadata_notified) {
 				/*
 				 * Since all the metadata has been sent to the
 				 * viewer and that we have a request to close
@@ -2028,6 +2262,9 @@ static int relay_recv_index(const struct lttcomm_relayd_hdr *recv_hdr,
 		index_info.stream_instance_id =
 				be64toh(index_info.stream_instance_id);
 		index_info.packet_seq_num = be64toh(index_info.packet_seq_num);
+	} else {
+		index_info.stream_instance_id = -1ULL;
+		index_info.packet_seq_num = -1ULL;
 	}
 
 	stream = stream_get_by_id(index_info.relay_stream_id);
@@ -2117,7 +2354,7 @@ static int relay_rotate_session_streams(
 		struct relay_connection *conn,
 		const struct lttng_buffer_view *payload)
 {
-	int ret;
+	int ret = 0;
 	uint32_t i;
 	ssize_t send_ret;
 	enum lttng_error_code reply_code = LTTNG_ERR_UNK;
@@ -2172,7 +2409,7 @@ static int relay_rotate_session_streams(
 				session->sessiond_uuid, session->id,
 				rotate_streams.new_chunk_id.value);
 		if (!next_trace_chunk) {
-			char uuid_str[UUID_STR_LEN];
+			char uuid_str[LTTNG_UUID_STR_LEN];
 
 			lttng_uuid_to_str(session->sessiond_uuid, uuid_str);
 			ERR("Unknown next trace chunk in ROTATE_STREAMS command: sessiond_uuid = {%s}, session_id = %" PRIu64
@@ -2238,6 +2475,7 @@ static int relay_rotate_session_streams(
 	}
 
 	reply_code = LTTNG_OK;
+	ret = 0;
 end:
 	if (stream) {
 		stream_put(stream);
@@ -2251,67 +2489,12 @@ end:
 				send_ret);
 		ret = -1;
 	}
-
 end_no_reply:
 	lttng_trace_chunk_put(next_trace_chunk);
 	return ret;
 }
 
-static int init_session_output_directory_handle(struct relay_session *session,
-		struct lttng_directory_handle *handle)
-{
-	int ret;
-	/* hostname/session_name */
-	char *session_directory = NULL;
-	/*
-	 * base path + session_directory
-	 * e.g. /home/user/lttng-traces/hostname/session_name
-	 */
-	char *full_session_path = NULL;
-	char creation_time_str[16];
-	struct tm *timeinfo;
-
-	assert(session->creation_time.is_set);
-	timeinfo = localtime(&session->creation_time.value);
-	if (!timeinfo) {
-		ret = -1;
-		goto end;
-	}
-	strftime(creation_time_str, sizeof(creation_time_str), "%Y%m%d-%H%M%S",
-			timeinfo);
 
-	pthread_mutex_lock(&session->lock);
-	ret = asprintf(&session_directory, "%s/%s-%s", session->hostname,
-			session->session_name, creation_time_str);
-	pthread_mutex_unlock(&session->lock);
-	if (ret < 0) {
-		PERROR("Failed to format session directory name");
-		goto end;
-	}
-
-	full_session_path = create_output_path(session_directory);
-	if (!full_session_path) {
-		ret = -1;
-		goto end;
-	}
-
-	ret = utils_mkdir_recursive(
-			full_session_path, S_IRWXU | S_IRWXG, -1, -1);
-	if (ret) {
-		ERR("Failed to create session output path \"%s\"",
-				full_session_path);
-		goto end;
-	}
-
-	ret = lttng_directory_handle_init(handle, full_session_path);
-	if (ret) {
-		goto end;
-	}
-end:
-	free(session_directory);
-	free(full_session_path);
-	return ret;
-}
 
 /*
  * relay_create_trace_chunk: create a new trace chunk
@@ -2330,7 +2513,8 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 	struct lttng_trace_chunk *chunk = NULL, *published_chunk = NULL;
 	enum lttng_error_code reply_code = LTTNG_OK;
 	enum lttng_trace_chunk_status chunk_status;
-	struct lttng_directory_handle session_output;
+	struct lttng_directory_handle *session_output = NULL;
+	const char *new_path;
 
 	if (!session || !conn->version_check_done) {
 		ERR("Trying to create a trace chunk before version check");
@@ -2357,8 +2541,29 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 	msg->creation_timestamp = be64toh(msg->creation_timestamp);
 	msg->override_name_length = be32toh(msg->override_name_length);
 
+	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,
+					DEFAULT_CHUNK_TMP_OLD_DIRECTORY);
+		if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+			ERR("Failed to rename old chunk");
+			ret = -1;
+			reply_code = LTTNG_ERR_UNK;
+			goto end;
+		}
+	}
+	session->ongoing_rotation = true;
+	if (!session->current_trace_chunk) {
+		if (!session->has_rotated) {
+			new_path = "";
+		} else {
+			new_path = NULL;
+		}
+	} else {
+		new_path = DEFAULT_CHUNK_TMP_NEW_DIRECTORY;
+	}
 	chunk = lttng_trace_chunk_create(
-			msg->chunk_id, msg->creation_timestamp);
+			msg->chunk_id, msg->creation_timestamp, new_path);
 	if (!chunk) {
 		ERR("Failed to create trace chunk in trace chunk creation command");
 		ret = -1;
@@ -2398,13 +2603,6 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 		}
 	}
 
-	ret = init_session_output_directory_handle(
-			conn->session, &session_output);
-	if (ret) {
-		reply_code = LTTNG_ERR_CREATE_DIR_FAIL;
-		goto end;
-	}
-
 	chunk_status = lttng_trace_chunk_set_credentials_current_user(chunk);
 	if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 		reply_code = LTTNG_ERR_UNK;
@@ -2412,7 +2610,15 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 		goto end;
 	}
 
-	chunk_status = lttng_trace_chunk_set_as_owner(chunk, &session_output);
+	session_output = session_create_output_directory_handle(
+			conn->session);
+	if (!session_output) {
+		reply_code = LTTNG_ERR_CREATE_DIR_FAIL;
+		goto end;
+	}
+	chunk_status = lttng_trace_chunk_set_as_owner(chunk, session_output);
+	lttng_directory_handle_put(session_output);
+	session_output = NULL;
 	if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 		reply_code = LTTNG_ERR_UNK;
 		ret = -1;
@@ -2425,7 +2631,7 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 			conn->session->id,
 			chunk);
 	if (!published_chunk) {
-		char uuid_str[UUID_STR_LEN];
+		char uuid_str[LTTNG_UUID_STR_LEN];
 
 		lttng_uuid_to_str(conn->session->sessiond_uuid, uuid_str);
 		ERR("Failed to publish chunk: sessiond_uuid = %s, session_id = %" PRIu64 ", chunk_id = %" PRIu64,
@@ -2452,6 +2658,9 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 			conn->session->current_trace_chunk;
 	conn->session->current_trace_chunk = published_chunk;
 	published_chunk = NULL;
+	if (!conn->session->pending_closure_trace_chunk) {
+		session->ongoing_rotation = false;
+	}
 end_unlock_session:
 	pthread_mutex_unlock(&conn->session->lock);
 end:
@@ -2468,7 +2677,7 @@ end:
 end_no_reply:
 	lttng_trace_chunk_put(chunk);
 	lttng_trace_chunk_put(published_chunk);
-	lttng_directory_handle_fini(&session_output);
+	lttng_directory_handle_put(session_output);
 	return ret;
 }
 
@@ -2479,11 +2688,11 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 		struct relay_connection *conn,
 		const struct lttng_buffer_view *payload)
 {
-	int ret = 0;
+	int ret = 0, buf_ret;
 	ssize_t send_ret;
 	struct relay_session *session = conn->session;
 	struct lttcomm_relayd_close_trace_chunk *msg;
-	struct lttcomm_relayd_generic_reply reply = {};
+	struct lttcomm_relayd_close_trace_chunk_reply reply = {};
 	struct lttng_buffer_view header_view;
 	struct lttng_trace_chunk *chunk = NULL;
 	enum lttng_error_code reply_code = LTTNG_OK;
@@ -2491,6 +2700,13 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 	uint64_t chunk_id;
 	LTTNG_OPTIONAL(enum lttng_trace_chunk_command_type) close_command = {};
 	time_t close_timestamp;
+	char closed_trace_chunk_path[LTTNG_PATH_MAX];
+	size_t path_length = 0;
+	const char *chunk_name = NULL;
+	struct lttng_dynamic_buffer reply_payload;
+	const char *new_path;
+
+	lttng_dynamic_buffer_init(&reply_payload);
 
 	if (!session || !conn->version_check_done) {
 		ERR("Trying to close a trace chunk before version check");
@@ -2526,7 +2742,7 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 			conn->session->id,
 			chunk_id);
 	if (!chunk) {
-		char uuid_str[UUID_STR_LEN];
+		char uuid_str[LTTNG_UUID_STR_LEN];
 
 		lttng_uuid_to_str(conn->session->sessiond_uuid, uuid_str);
 		ERR("Failed to find chunk to close: sessiond_uuid = %s, session_id = %" PRIu64 ", chunk_id = %" PRIu64,
@@ -2539,6 +2755,20 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 	}
 
 	pthread_mutex_lock(&session->lock);
+	if (close_command.is_set &&
+			close_command.value == LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE) {
+		/*
+		 * Clear command. It is a protocol error to ask for a
+		 * clear on a relay which does not allow it. Querying
+		 * the configuration allows figuring out whether
+		 * clearing is allowed before doing the clear.
+		 */
+		if (!opt_allow_clear) {
+			ret = -1;
+			reply_code = LTTNG_ERR_INVALID_PROTOCOL;
+			goto end_unlock_session;
+		}
+	}
 	if (session->pending_closure_trace_chunk &&
 			session->pending_closure_trace_chunk != chunk) {
 		ERR("Trace chunk close command for session \"%s\" does not target the trace chunk pending closure",
@@ -2548,6 +2778,43 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 		goto end_unlock_session;
 	}
 
+	if (session->current_trace_chunk && session->current_trace_chunk != chunk &&
+			!lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) {
+		if (close_command.is_set &&
+				close_command.value == LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE &&
+				!session->has_rotated) {
+			/* New chunk stays in session output directory. */
+			new_path = "";
+		} else {
+			/* Use chunk name for new chunk. */
+			new_path = NULL;
+		}
+		/* Rename new chunk path. */
+		chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk,
+				new_path);
+		if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+			ret = -1;
+			goto end;
+		}
+		session->ongoing_rotation = false;
+	}
+	if ((!close_command.is_set ||
+			close_command.value == LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION) &&
+			!lttng_trace_chunk_get_name_overridden(chunk)) {
+		const char *old_path;
+
+		if (!session->has_rotated) {
+			old_path = "";
+		} else {
+			old_path = NULL;
+		}
+		/* We need to move back the .tmp_old_chunk to its rightful place. */
+		chunk_status = lttng_trace_chunk_rename_path(chunk, old_path);
+		if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+			ret = -1;
+			goto end;
+		}
+	}
 	chunk_status = lttng_trace_chunk_set_close_timestamp(
 			chunk, close_timestamp);
 	if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
@@ -2566,6 +2833,57 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 			goto end_unlock_session;
 		}
 	}
+	chunk_status = lttng_trace_chunk_get_name(chunk, &chunk_name, NULL);
+	if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+		ERR("Failed to get chunk name");
+		ret = -1;
+		reply_code = LTTNG_ERR_UNK;
+		goto end_unlock_session;
+	}
+	if (!session->has_rotated && !session->snapshot) {
+		ret = lttng_strncpy(closed_trace_chunk_path,
+				session->output_path,
+				sizeof(closed_trace_chunk_path));
+		if (ret) {
+			ERR("Failed to send trace chunk path: path length of %zu bytes exceeds the maximal allowed length of %zu bytes",
+					strlen(session->output_path),
+					sizeof(closed_trace_chunk_path));
+			reply_code = LTTNG_ERR_NOMEM;
+			ret = -1;
+			goto end_unlock_session;
+		}
+	} else {
+		if (session->snapshot) {
+			ret = snprintf(closed_trace_chunk_path,
+					sizeof(closed_trace_chunk_path),
+					"%s/%s", session->output_path,
+					chunk_name);
+		} else {
+			ret = snprintf(closed_trace_chunk_path,
+					sizeof(closed_trace_chunk_path),
+					"%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
+					"/%s",
+					session->output_path, chunk_name);
+		}
+		if (ret < 0 || ret == sizeof(closed_trace_chunk_path)) {
+			ERR("Failed to format closed trace chunk resulting path");
+			reply_code = ret < 0 ? LTTNG_ERR_UNK : LTTNG_ERR_NOMEM;
+			ret = -1;
+			goto end_unlock_session;
+		}
+	}
+	if (close_command.is_set &&
+			close_command.value == LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED) {
+		session->has_rotated = true;
+	}
+	DBG("Reply chunk path on close: %s", closed_trace_chunk_path);
+	path_length = strlen(closed_trace_chunk_path) + 1;
+	if (path_length > UINT32_MAX) {
+		ERR("Closed trace chunk path exceeds the maximal length allowed by the protocol");
+		ret = -1;
+		reply_code = LTTNG_ERR_INVALID_PROTOCOL;
+		goto end_unlock_session;
+	}
 
 	if (session->current_trace_chunk == chunk) {
 		/*
@@ -2585,18 +2903,37 @@ end_unlock_session:
 	pthread_mutex_unlock(&session->lock);
 
 end:
-	reply.ret_code = htobe32((uint32_t) reply_code);
+	reply.generic.ret_code = htobe32((uint32_t) reply_code);
+	reply.path_length = htobe32((uint32_t) path_length);
+	buf_ret = lttng_dynamic_buffer_append(
+			&reply_payload, &reply, sizeof(reply));
+	if (buf_ret) {
+		ERR("Failed to append \"close trace chunk\" command reply header to payload buffer");
+		goto end_no_reply;
+	}
+
+	if (reply_code == LTTNG_OK) {
+		buf_ret = lttng_dynamic_buffer_append(&reply_payload,
+				closed_trace_chunk_path, path_length);
+		if (buf_ret) {
+			ERR("Failed to append \"close trace chunk\" command reply path to payload buffer");
+			goto end_no_reply;
+		}
+	}
+
 	send_ret = conn->sock->ops->sendmsg(conn->sock,
-			&reply,
-			sizeof(struct lttcomm_relayd_generic_reply),
+			reply_payload.data,
+			reply_payload.size,
 			0);
-	if (send_ret < (ssize_t) sizeof(reply)) {
-		ERR("Failed to send \"create trace chunk\" command reply (ret = %zd)",
-				send_ret);
+	if (send_ret < reply_payload.size) {
+		ERR("Failed to send \"close trace chunk\" command reply of %zu bytes (ret = %zd)",
+				reply_payload.size, send_ret);
 		ret = -1;
+		goto end_no_reply;
 	}
 end_no_reply:
 	lttng_trace_chunk_put(chunk);
+	lttng_dynamic_buffer_reset(&reply_payload);
 	return ret;
 }
 
@@ -2613,8 +2950,8 @@ static int relay_trace_chunk_exists(const struct lttcomm_relayd_hdr *recv_hdr,
 	struct lttcomm_relayd_trace_chunk_exists *msg;
 	struct lttcomm_relayd_trace_chunk_exists_reply reply = {};
 	struct lttng_buffer_view header_view;
-	struct lttng_trace_chunk *chunk = NULL;
 	uint64_t chunk_id;
+	bool chunk_exists;
 
 	if (!session || !conn->version_check_done) {
 		ERR("Trying to close a trace chunk before version check");
@@ -2639,25 +2976,80 @@ static int relay_trace_chunk_exists(const struct lttcomm_relayd_hdr *recv_hdr,
 	msg = (typeof(msg)) header_view.data;
 	chunk_id = be64toh(msg->chunk_id);
 
-	chunk = sessiond_trace_chunk_registry_get_chunk(
+	ret = sessiond_trace_chunk_registry_chunk_exists(
 			sessiond_trace_chunk_registry,
 			conn->session->sessiond_uuid,
 			conn->session->id,
-			chunk_id);
-
-	reply = (typeof(reply)) {
-		.generic.ret_code = htobe32((uint32_t) LTTNG_OK),
-		.trace_chunk_exists = !!chunk,
+			chunk_id, &chunk_exists);
+	/*
+	 * If ret is not 0, send the reply and report the error to the caller.
+	 * It is a protocol (or internal) error and the session/connection
+	 * should be torn down.
+	 */
+	reply = (typeof(reply)){
+		.generic.ret_code = htobe32((uint32_t)
+			(ret == 0 ? LTTNG_OK : LTTNG_ERR_INVALID_PROTOCOL)),
+		.trace_chunk_exists = ret == 0 ? chunk_exists : 0,
 	};
-	send_ret = conn->sock->ops->sendmsg(conn->sock,
-			&reply, sizeof(reply), 0);
+	send_ret = conn->sock->ops->sendmsg(
+			conn->sock, &reply, sizeof(reply), 0);
 	if (send_ret < (ssize_t) sizeof(reply)) {
 		ERR("Failed to send \"create trace chunk\" command reply (ret = %zd)",
 				send_ret);
 		ret = -1;
 	}
 end_no_reply:
-	lttng_trace_chunk_put(chunk);
+	return ret;
+}
+
+/*
+ * relay_get_configuration: query whether feature is available
+ */
+static int relay_get_configuration(const struct lttcomm_relayd_hdr *recv_hdr,
+		struct relay_connection *conn,
+		const struct lttng_buffer_view *payload)
+{
+	int ret = 0;
+	ssize_t send_ret;
+	struct lttcomm_relayd_get_configuration *msg;
+	struct lttcomm_relayd_get_configuration_reply reply = {};
+	struct lttng_buffer_view header_view;
+	uint64_t query_flags = 0;
+	uint64_t result_flags = 0;
+
+	header_view = lttng_buffer_view_from_view(payload, 0, sizeof(*msg));
+	if (!header_view.data) {
+		ERR("Failed to receive payload of chunk close command");
+		ret = -1;
+		goto end_no_reply;
+	}
+
+	/* Convert to host endianness. */
+	msg = (typeof(msg)) header_view.data;
+	query_flags = be64toh(msg->query_flags);
+
+	if (query_flags) {
+		ret = LTTNG_ERR_INVALID_PROTOCOL;
+		goto reply;
+	}
+	if (opt_allow_clear) {
+		result_flags |= LTTCOMM_RELAYD_CONFIGURATION_FLAG_CLEAR_ALLOWED;
+	}
+	ret = 0;
+reply:
+	reply = (typeof(reply)){
+		.generic.ret_code = htobe32((uint32_t)
+			(ret == 0 ? LTTNG_OK : LTTNG_ERR_INVALID_PROTOCOL)),
+		.relayd_configuration_flags = htobe64(result_flags),
+	};
+	send_ret = conn->sock->ops->sendmsg(
+			conn->sock, &reply, sizeof(reply), 0);
+	if (send_ret < (ssize_t) sizeof(reply)) {
+		ERR("Failed to send \"get configuration\" command reply (ret = %zd)",
+				send_ret);
+		ret = -1;
+	}
+end_no_reply:
 	return ret;
 }
 
@@ -2739,6 +3131,10 @@ static int relay_process_control_command(struct relay_connection *conn,
 		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:
 	default:
 		ERR("Received unknown command (%u)", header->cmd);
@@ -3338,8 +3734,13 @@ restart:
 					if (ret < 0) {
 						goto error;
 					}
-					lttng_poll_add(&events, conn->sock->fd,
+					ret = lttng_poll_add(&events,
+							conn->sock->fd,
 							LPOLLIN | LPOLLRDHUP);
+					if (ret) {
+						ERR("Failed to add new connection file descriptor to poll set");
+						goto error;
+					}
 					connection_ht_add(relay_connections_ht, conn);
 					DBG("Connection socket %d added", conn->sock->fd);
 				} else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
@@ -3580,10 +3981,21 @@ static int create_relay_conn_pipe(void)
  */
 int main(int argc, char **argv)
 {
+	bool thread_is_rcu_registered = false;
 	int ret = 0, retval = 0;
 	void *status;
 
-	/* Parse arguments */
+	/* Parse environment variables */
+	ret = parse_env_options();
+	if (ret) {
+		retval = -1;
+		goto exit_options;
+	}
+
+	/*
+	 * Parse arguments.
+	 * Command line arguments overwrite environment.
+	 */
 	progname = argv[0];
 	if (set_options(argc, argv)) {
 		retval = -1;
@@ -3595,6 +4007,22 @@ int main(int argc, char **argv)
 		goto exit_options;
 	}
 
+	relayd_config_log();
+
+	if (opt_print_version) {
+		print_version();
+		retval = 0;
+		goto exit_options;
+	}
+
+	ret = fclose(stdin);
+	if (ret) {
+		PERROR("Failed to close stdin");
+		goto exit_options;
+	}
+
+	DBG("Clear command %s", opt_allow_clear ? "allowed" : "disallowed");
+
 	/* Try to create directory if -o, --output is specified. */
 	if (opt_output_path) {
 		if (*opt_output_path != '/') {
@@ -3614,22 +4042,19 @@ int main(int argc, char **argv)
 
 	/* Daemonize */
 	if (opt_daemon || opt_background) {
-		int i;
-
 		ret = lttng_daemonize(&child_ppid, &recv_child_signal,
 			!opt_background);
 		if (ret < 0) {
 			retval = -1;
 			goto exit_options;
 		}
+	}
 
-		/*
-		 * We are in the child. Make sure all other file
-		 * descriptors are closed, in case we are called with
-		 * more opened file descriptors than the standard ones.
-		 */
-		for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
-			(void) close(i);
+	if (opt_working_directory) {
+		ret = utils_change_working_directory(opt_working_directory);
+		if (ret) {
+			/* All errors are already logged. */
+			goto exit_options;
 		}
 	}
 
@@ -3637,7 +4062,22 @@ int main(int argc, char **argv)
 	if (!sessiond_trace_chunk_registry) {
 		ERR("Failed to initialize session daemon trace chunk registry");
 		retval = -1;
-		goto exit_sessiond_trace_chunk_registry;
+		goto exit_options;
+	}
+
+	/*
+	 * The RCU thread registration (and use, through the fd-tracker's
+	 * creation) is done after the daemonization to allow us to not
+	 * deal with liburcu's fork() management as the call RCU needs to
+	 * be restored.
+	 */
+	rcu_register_thread();
+	thread_is_rcu_registered = true;
+
+	the_fd_tracker = fd_tracker_create(lttng_opt_fd_cap);
+	if (!the_fd_tracker) {
+		retval = -1;
+		goto exit_options;
 	}
 
 	/* Initialize thread health monitoring */
@@ -3645,19 +4085,19 @@ int main(int argc, char **argv)
 	if (!health_relayd) {
 		PERROR("health_app_create error");
 		retval = -1;
-		goto exit_health_app_create;
+		goto exit_options;
 	}
 
 	/* Create thread quit pipe */
 	if (init_thread_quit_pipe()) {
 		retval = -1;
-		goto exit_init_data;
+		goto exit_options;
 	}
 
 	/* Setup the thread apps communication pipe. */
 	if (create_relay_conn_pipe()) {
 		retval = -1;
-		goto exit_init_data;
+		goto exit_options;
 	}
 
 	/* Init relay command queue. */
@@ -3671,27 +4111,27 @@ int main(int argc, char **argv)
 	sessions_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
 	if (!sessions_ht) {
 		retval = -1;
-		goto exit_init_data;
+		goto exit_options;
 	}
 
 	/* tables of streams indexed by stream ID */
 	relay_streams_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
 	if (!relay_streams_ht) {
 		retval = -1;
-		goto exit_init_data;
+		goto exit_options;
 	}
 
 	/* tables of streams indexed by stream ID */
 	viewer_streams_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
 	if (!viewer_streams_ht) {
 		retval = -1;
-		goto exit_init_data;
+		goto exit_options;
 	}
 
 	ret = utils_create_pipe(health_quit_pipe);
 	if (ret) {
 		retval = -1;
-		goto exit_health_quit_pipe;
+		goto exit_options;
 	}
 
 	/* Create thread to manage the client socket */
@@ -3701,7 +4141,7 @@ int main(int argc, char **argv)
 		errno = ret;
 		PERROR("pthread_create health");
 		retval = -1;
-		goto exit_health_thread;
+		goto exit_options;
 	}
 
 	/* Setup the dispatcher thread */
@@ -3782,16 +4222,6 @@ exit_dispatcher_thread:
 		PERROR("pthread_join health_thread");
 		retval = -1;
 	}
-exit_health_thread:
-
-	utils_close_pipe(health_quit_pipe);
-exit_health_quit_pipe:
-
-exit_init_data:
-	health_app_destroy(health_relayd);
-	sessiond_trace_chunk_registry_destroy(sessiond_trace_chunk_registry);
-exit_health_app_create:
-exit_sessiond_trace_chunk_registry:
 exit_options:
 	/*
 	 * Wait for all pending call_rcu work to complete before tearing
@@ -3804,6 +4234,10 @@ exit_options:
 	/* Ensure all prior call_rcu are done. */
 	rcu_barrier();
 
+	if (thread_is_rcu_registered) {
+		rcu_unregister_thread();
+	}
+
 	if (!retval) {
 		exit(EXIT_SUCCESS);
 	} else {