X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fmain.c;h=5f72c32a906f700ec14009766d056ead3e49b375;hp=a2904eb08ae044faa2109338f4af5fe1d0c764b2;hb=2a10de3b3b5a198a1633ff4167a9610c493994c1;hpb=46ef21888c975515837d5dab104c938c424792ed

diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c
index a2904eb08..5f72c32a9 100644
--- a/src/bin/lttng-relayd/main.c
+++ b/src/bin/lttng-relayd/main.c
@@ -40,6 +40,7 @@
 #include <urcu/rculist.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <strings.h>
 
 #include <lttng/lttng.h>
 #include <common/common.h>
@@ -61,6 +62,7 @@
 #include <common/buffer-view.h>
 #include <common/string-utils/format.h>
 
+#include "version.h"
 #include "cmd.h"
 #include "ctf-trace.h"
 #include "index.h"
@@ -94,8 +96,8 @@ 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;
 
 /*
  * We need to wait for listener and live listener threads, as well as
@@ -182,11 +184,29 @@ static struct option long_options[] = {
 	{ "verbose", 0, 0, 'v', },
 	{ "config", 1, 0, 'f' },
 	{ "version", 0, 0, 'V' },
+	{ "working-directory", 1, 0, 'w', },
 	{ 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.
@@ -277,8 +297,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 +312,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) {
@@ -372,6 +406,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;
@@ -522,8 +573,8 @@ 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);
 
 	/* Close thread quit pipes */
 	utils_close_pipe(thread_quit_pipe);
@@ -1068,7 +1119,7 @@ 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;
@@ -1080,6 +1131,9 @@ static int relay_create_session(const struct lttcomm_relayd_hdr *recv_hdr,
 	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 */
@@ -1133,24 +1187,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;
 }
 
@@ -2195,6 +2284,7 @@ static int relay_rotate_session_streams(
 		} else {
 			chunk_id_str = chunk_id_buf;
 		}
+		session->has_rotated = true;
 	}
 
 	DBG("Rotate %" PRIu32 " streams of session \"%s\" to chunk \"%s\"",
@@ -2242,6 +2332,7 @@ static int relay_rotate_session_streams(
 	}
 
 	reply_code = LTTNG_OK;
+	ret = 0;
 end:
 	if (stream) {
 		stream_put(stream);
@@ -2255,120 +2346,12 @@ end:
 				send_ret);
 		ret = -1;
 	}
-
-	ret = 0;
 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;
-	/*
-	 * session_directory:
-	 *
-	 * if base_path is \0'
-	 *   hostname/session_name
-	 * else
-	 *   hostname/base_path
-	 */
-	char *session_directory = NULL;
-	/*
-	 * relayd_output_path/session_directory
-	 * e.g. /home/user/lttng-traces/hostname/session_name
-	 */
-	char *full_session_path = NULL;
-
-	/*
-	 * If base path is set, it overrides the session name for the
-	 * session relative base path. No timestamp is appended if the
-	 * base path is overridden.
-	 *
-	 * If the session name already contains the creation time (e.g.
-	 * auto-<timestamp>, don't append yet another timestamp after
-	 * the session name in the generated path.
-	 *
-	 * Otherwise, generate the path with session_name-<timestamp>.
-	 */
-	if (session->base_path[0] != '\0') {
-		pthread_mutex_lock(&session->lock);
-		ret = asprintf(&session_directory, "%s/%s", session->hostname,
-				session->base_path);
-		pthread_mutex_unlock(&session->lock);
-	} else if (session->session_name_contains_creation_time) {
-		pthread_mutex_lock(&session->lock);
-		ret = asprintf(&session_directory, "%s/%s", session->hostname,
-				session->session_name);
-		pthread_mutex_unlock(&session->lock);
-	} else {
-		char session_creation_datetime[16];
-		size_t strftime_ret;
-		struct tm *timeinfo;
-		time_t creation_time;
-
-		/*
-		 * The 2.11+ protocol guarantees that a creation time
-		 * is provided for a session. This would indicate a
-		 * protocol error or an improper use of this util.
-		 */
-		if (!session->creation_time.is_set) {
-			ERR("Creation time missing for session \"%s\" (protocol error)",
-					session->session_name);
-			ret = -1;
-			goto end;
-		}
-		creation_time = LTTNG_OPTIONAL_GET(session->creation_time);
 
-		timeinfo = localtime(&creation_time);
-		if (!timeinfo) {
-			ERR("Failed to get timeinfo while initializing session output directory handle");
-			ret = -1;
-			goto end;
-		}
-		strftime_ret = strftime(session_creation_datetime,
-				sizeof(session_creation_datetime),
-				"%Y%m%d-%H%M%S", timeinfo);
-		if (strftime_ret == 0) {
-			ERR("Failed to format session creation timestamp while initializing session output directory handle");
-			ret = -1;
-			goto end;
-		}
-		pthread_mutex_lock(&session->lock);
-		ret = asprintf(&session_directory, "%s/%s-%s",
-				session->hostname, session->session_name,
-				session_creation_datetime);
-		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
@@ -2455,13 +2438,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;
@@ -2469,7 +2445,14 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
 		goto end;
 	}
 
+	ret = session_init_output_directory_handle(
+			conn->session, &session_output);
+	if (ret) {
+		reply_code = LTTNG_ERR_CREATE_DIR_FAIL;
+		goto end;
+	}
 	chunk_status = lttng_trace_chunk_set_as_owner(chunk, &session_output);
+	lttng_directory_handle_fini(&session_output);
 	if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 		reply_code = LTTNG_ERR_UNK;
 		ret = -1;
@@ -2525,7 +2508,6 @@ end:
 end_no_reply:
 	lttng_trace_chunk_put(chunk);
 	lttng_trace_chunk_put(published_chunk);
-	lttng_directory_handle_fini(&session_output);
 	return ret;
 }
 
@@ -2536,11 +2518,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;
@@ -2548,6 +2530,12 @@ 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;
+
+	lttng_dynamic_buffer_init(&reply_payload);
 
 	if (!session || !conn->version_check_done) {
 		ERR("Trying to close a trace chunk before version check");
@@ -2623,6 +2611,53 @@ 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;
+		}
+	}
+	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) {
 		/*
@@ -2642,18 +2677,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;
 }
 
@@ -2670,8 +2724,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");
@@ -2696,25 +2750,29 @@ 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;
 }
 
@@ -3395,8 +3453,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)) {
@@ -3640,7 +3703,17 @@ int main(int argc, char **argv)
 	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;
@@ -3652,6 +3725,14 @@ int main(int argc, char **argv)
 		goto exit_options;
 	}
 
+	relayd_config_log();
+
+	if (opt_print_version) {
+		print_version();
+		retval = 0;
+		goto exit_options;
+	}
+
 	/* Try to create directory if -o, --output is specified. */
 	if (opt_output_path) {
 		if (*opt_output_path != '/') {
@@ -3690,6 +3771,14 @@ int main(int argc, char **argv)
 		}
 	}
 
+	if (opt_working_directory) {
+		ret = utils_change_working_directory(opt_working_directory);
+		if (ret) {
+			/* All errors are already logged. */
+			goto exit_options;
+		}
+	}
+
 	sessiond_trace_chunk_registry = sessiond_trace_chunk_registry_create();
 	if (!sessiond_trace_chunk_registry) {
 		ERR("Failed to initialize session daemon trace chunk registry");