X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=50bacf0c236dc3ea4917a6f4100a80aa39b98623;hp=53a72d9b8d9129e04faac25ab84d81f214d2babd;hb=d5a1b7aa06b4c924b1cd30623758343c74ecab5c;hpb=47e52862a8330d41800736a69de93cec9287cc9d

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index 53a72d9b8..50bacf0c2 100644
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -57,7 +57,7 @@
 #include "notification-thread-commands.h"
 #include "rotate.h"
 #include "rotation-thread.h"
-#include "sessiond-timer.h"
+#include "timer.h"
 #include "agent-thread.h"
 
 #include "cmd.h"
@@ -2701,7 +2701,7 @@ int cmd_start_trace(struct ltt_session *session)
 	session->rotated_after_last_stop = false;
 
 	if (session->rotate_timer_period) {
-		ret = sessiond_rotate_timer_start(session,
+		ret = timer_session_rotation_schedule_timer_start(session,
 				session->rotate_timer_period);
 		if (ret < 0) {
 			ERR("Failed to enable rotate timer");
@@ -2716,48 +2716,6 @@ error:
 	return ret;
 }
 
-static
-int rename_active_chunk(struct ltt_session *session)
-{
-	int ret;
-
-	session->current_archive_id++;
-
-	/*
-	 * The currently active tracing path is now the folder we
-	 * want to rename.
-	 */
-	ret = lttng_strncpy(session->rotation_chunk.current_rotate_path,
-			session->rotation_chunk.active_tracing_path,
-			sizeof(session->rotation_chunk.current_rotate_path));
-	if (ret) {
-		ERR("Failed to copy active tracing path");
-		goto end;
-	}
-
-	ret = rename_complete_chunk(session, time(NULL));
-	if (ret < 0) {
-		ERR("Failed to rename current rotate path");
-		goto end;
-	}
-
-	/*
-	 * We just renamed, the folder, we didn't do an actual rotation, so
-	 * the active tracing path is now the renamed folder and we have to
-	 * restore the rotate count.
-	 */
-	ret = lttng_strncpy(session->rotation_chunk.active_tracing_path,
-			session->rotation_chunk.current_rotate_path,
-			sizeof(session->rotation_chunk.active_tracing_path));
-	if (ret) {
-		ERR("Failed to rename active session chunk tracing path");
-		goto end;
-	}
-end:
-	session->current_archive_id--;
-	return ret;
-}
-
 /*
  * Command LTTNG_STOP_TRACE processed by the client thread.
  */
@@ -2782,15 +2740,22 @@ int cmd_stop_trace(struct ltt_session *session)
 		goto error;
 	}
 
-	if (session->rotate_relay_pending_timer_enabled) {
-		sessiond_timer_rotate_pending_stop(session);
-	}
-
-	if (session->rotate_timer_enabled) {
-		sessiond_rotate_timer_stop(session);
+	if (session->rotation_schedule_timer_enabled) {
+		if (timer_session_rotation_schedule_timer_stop(
+				session)) {
+			ERR("Failed to stop the \"rotation schedule\" timer of session %s",
+					session->name);
+		}
 	}
 
-	if (session->current_archive_id > 0 && !session->rotate_pending) {
+	/*
+	 * A rotation is still ongoing. The check timer will continue to wait
+	 * for the rotation to complete. When the rotation finally completes,
+	 * a check will be performed to rename the "active" chunk to the
+	 * expected "timestamp_begin-timestamp_end" format.
+	 */
+	if (session->current_archive_id > 0 &&
+			session->rotation_state != LTTNG_ROTATION_STATE_ONGOING) {
 		ret = rename_active_chunk(session);
 		if (ret) {
 			/*
@@ -3089,12 +3054,19 @@ int cmd_destroy_session(struct ltt_session *session, int wpipe,
 
 	DBG("Begin destroy session %s (id %" PRIu64 ")", session->name, session->id);
 
-	if (session->rotate_relay_pending_timer_enabled) {
-		sessiond_timer_rotate_pending_stop(session);
+	if (session->rotation_pending_check_timer_enabled) {
+		if (timer_session_rotation_pending_check_stop(session)) {
+			ERR("Failed to stop the \"rotation pending check\" timer of session %s",
+					session->name);
+		}
 	}
 
-	if (session->rotate_timer_enabled) {
-		sessiond_rotate_timer_stop(session);
+	if (session->rotation_schedule_timer_enabled) {
+		if (timer_session_rotation_schedule_timer_stop(
+				session)) {
+			ERR("Failed to stop the \"rotation schedule\" timer of session %s",
+					session->name);
+		}
 	}
 
 	if (session->rotate_size) {
@@ -3564,10 +3536,8 @@ int cmd_data_pending(struct ltt_session *session)
 		}
 	}
 
-	/*
-	 * A rotation is still pending, we have to wait.
-	 */
-	if (session->rotate_pending) {
+	/* A rotation is still pending, we have to wait. */
+	if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
 		DBG("Rotate still pending for session %s", session->name);
 		ret = 1;
 		goto error;
@@ -4551,28 +4521,33 @@ int cmd_set_session_shm_path(struct ltt_session *session,
  * Ask the consumer to rotate the session output directory.
  * The session lock must be held.
  *
- * Return LTTNG_OK on success or else a LTTNG_ERR code.
+ * Returns LTTNG_OK on success or else a negative LTTng error code.
  */
 int cmd_rotate_session(struct ltt_session *session,
 		struct lttng_rotate_session_return *rotate_return)
 {
 	int ret;
+	enum lttng_error_code cmd_ret = LTTNG_OK;
 	size_t strf_ret;
 	struct tm *timeinfo;
 	char datetime[21];
 	time_t now;
-	bool ust_active = false;
+	/*
+	 * Used to roll-back timestamps in case of failure to launch the
+	 * rotation.
+	 */
+	time_t original_last_chunk_start_ts, original_current_chunk_start_ts;
 
 	assert(session);
 
 	if (!session->has_been_started) {
-		ret = -LTTNG_ERR_START_SESSION_ONCE;
+		cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
 		goto end;
 	}
 
 	if (session->live_timer || session->snapshot_mode ||
 			!session->output_traces) {
-		ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE;
+		cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
 		goto end;
 	}
 
@@ -4582,13 +4557,14 @@ int cmd_rotate_session(struct ltt_session *session,
 	if (session->consumer->type == CONSUMER_DST_NET &&
 			(session->consumer->relay_major_version == 2 &&
 			session->consumer->relay_minor_version < 11)) {
-		ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY;
+		cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY;
 		goto end;
 	}
 
-	if (session->rotate_pending || session->rotate_pending_relay) {
-		ret = -LTTNG_ERR_ROTATION_PENDING;
-		DBG("Rotate already in progress");
+	if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
+		DBG("Refusing to launch a rotation; a rotation is already in progress for session %s",
+				session->name);
+		cmd_ret = LTTNG_ERR_ROTATION_PENDING;
 		goto end;
 	}
 
@@ -4599,7 +4575,7 @@ int cmd_rotate_session(struct ltt_session *session,
 	if (session->rotated_after_last_stop) {
 		DBG("Session \"%s\" was already rotated after stop, refusing rotation",
 				session->name);
-		ret = -LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
+		cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
 		goto end;
 	}
 
@@ -4607,21 +4583,17 @@ int cmd_rotate_session(struct ltt_session *session,
 	if (session->current_archive_id == 0) {
 		const char *base_path = NULL;
 
+		assert(session->kernel_session || session->ust_session);
 		/* Either one of the two sessions is enough to get the root path. */
-		if (session->kernel_session) {
-			base_path = session_get_base_path(session);
-		} else if (session->ust_session) {
-			base_path = session_get_base_path(session);
-		} else {
-			assert(0);
-		}
+		base_path = session_get_base_path(session);
 		assert(base_path);
+
 		ret = lttng_strncpy(session->rotation_chunk.current_rotate_path,
 				base_path,
 				sizeof(session->rotation_chunk.current_rotate_path));
 		if (ret) {
 			ERR("Failed to copy session base path to current rotation chunk path");
-			ret = -LTTNG_ERR_UNK;
+			cmd_ret = LTTNG_ERR_UNK;
 			goto end;
 		}
 	} else {
@@ -4634,48 +4606,54 @@ int cmd_rotate_session(struct ltt_session *session,
 				sizeof(session->rotation_chunk.current_rotate_path));
 		if (ret) {
 			ERR("Failed to copy the active tracing path to the current rotate path");
-			ret = -LTTNG_ERR_UNK;
+			cmd_ret = LTTNG_ERR_UNK;
 			goto end;
 		}
 	}
 	DBG("Current rotate path %s", session->rotation_chunk.current_rotate_path);
 
-	session->current_archive_id++;
-	session->rotate_pending = true;
-	session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
-	ret = notification_thread_command_session_rotation_ongoing(
-			notification_thread_handle,
-			session->name, session->uid, session->gid,
-			session->current_archive_id);
-	if (ret != LTTNG_OK) {
-		ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",
-				session->name);
-	}
-
 	/*
-	 * Create the path name for the next chunk.
+	 * Channels created after this point will belong to the next
+	 * archive id.
 	 */
+	session->current_archive_id++;
+
 	now = time(NULL);
 	if (now == (time_t) -1) {
-		ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE;
+		cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
 		goto end;
 	}
+
+	/* Sample chunk bounds for roll-back in case of error. */
+	original_last_chunk_start_ts = session->last_chunk_start_ts;
+	original_current_chunk_start_ts = session->current_chunk_start_ts;
+
 	session->last_chunk_start_ts = session->current_chunk_start_ts;
 	session->current_chunk_start_ts = now;
 
 	timeinfo = localtime(&now);
 	if (!timeinfo) {
 		PERROR("Failed to sample local time in rotate session command");
-		ret = -LTTNG_ERR_UNK;
+		cmd_ret = LTTNG_ERR_UNK;
 		goto end;
 	}
 	strf_ret = strftime(datetime, sizeof(datetime), "%Y%m%dT%H%M%S%z",
 			timeinfo);
 	if (!strf_ret) {
 		ERR("Failed to format local time timestamp in rotate session command");
-		ret = -LTTNG_ERR_UNK;
+		cmd_ret = LTTNG_ERR_UNK;
 		goto end;
 	}
+
+	/*
+	 * A rotation has a local step even if the destination is a relay
+	 * daemon; the buffers must be consumed by the consumer daemon.
+	 */
+	session->rotation_pending_local = true;
+	session->rotation_pending_relay =
+		session_get_consumer_destination_type(session) == CONSUMER_DST_NET;
+	session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
+
 	if (session->kernel_session) {
 		/*
 		 * The active path for the next rotation/destroy.
@@ -4688,8 +4666,8 @@ int cmd_rotate_session(struct ltt_session *session,
 				datetime, session->current_archive_id + 1);
 		if (ret < 0 || ret == sizeof(session->rotation_chunk.active_tracing_path)) {
 			ERR("Failed to format active kernel tracing path in rotate session command");
-			ret = -LTTNG_ERR_UNK;
-			goto end;
+			cmd_ret = LTTNG_ERR_UNK;
+			goto error;
 		}
 		/*
 		 * The sub-directory for the consumer
@@ -4701,8 +4679,8 @@ int cmd_rotate_session(struct ltt_session *session,
 				session->current_archive_id + 1);
 		if (ret < 0 || ret == sizeof(session->kernel_session->consumer->chunk_path)) {
 			ERR("Failed to format the kernel consumer's sub-directory in rotate session command");
-			ret = -LTTNG_ERR_UNK;
-			goto end;
+			cmd_ret = LTTNG_ERR_UNK;
+			goto error;
 		}
 		/*
 		 * Create the new chunk folder, before the rotation begins so we don't
@@ -4714,13 +4692,12 @@ int cmd_rotate_session(struct ltt_session *session,
 		if (ret) {
 			ERR("Failed to create kernel session tracing path at %s",
 					session->kernel_session->consumer->chunk_path);
-			ret = -LTTNG_ERR_CREATE_DIR_FAIL;
-			goto end;
+			cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
+			goto error;
 		}
-		ret = kernel_rotate_session(session);
-		if (ret != LTTNG_OK) {
-			ret = -ret;
-			goto end;
+		cmd_ret = kernel_rotate_session(session);
+		if (cmd_ret != LTTNG_OK) {
+			goto error;
 		}
 	}
 	if (session->ust_session) {
@@ -4730,16 +4707,16 @@ int cmd_rotate_session(struct ltt_session *session,
 				datetime, session->current_archive_id + 1);
 		if (ret < 0) {
 			ERR("Failed to format active UST tracing path in rotate session command");
-			ret = -LTTNG_ERR_UNK;
-			goto end;
+			cmd_ret = LTTNG_ERR_UNK;
+			goto error;
 		}
 		ret = snprintf(session->ust_session->consumer->chunk_path,
 				PATH_MAX, "/%s-%" PRIu64, datetime,
 				session->current_archive_id + 1);
 		if (ret < 0) {
 			ERR("Failed to format the UST consumer's sub-directory in rotate session command");
-			ret = -LTTNG_ERR_UNK;
-			goto end;
+			cmd_ret = LTTNG_ERR_UNK;
+			goto error;
 		}
 		/*
 		 * Create the new chunk folder, before the rotation begins so we don't
@@ -4749,46 +4726,26 @@ int cmd_rotate_session(struct ltt_session *session,
 				session->ust_session->uid,
 				session->ust_session->gid);
 		if (ret) {
-			ret = -LTTNG_ERR_CREATE_DIR_FAIL;
-			goto end;
-		}
-		ret = ust_app_rotate_session(session, &ust_active);
-		if (ret != LTTNG_OK) {
-			goto end;
+			cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
+			goto error;
 		}
 		/*
-		 * Handle the case where we did not start a rotation on any channel.
-		 * The consumer will never wake up the rotation thread to perform the
-		 * rename, so we have to do it here while we hold the session and
-		 * session_list locks.
+		 * TODO: ust_app_rotate_session must be adapted to return
+		 * an lttng_error_code, like its kernel counterpart.
 		 */
-		if (!session->kernel_session && !ust_active) {
-			struct lttng_trace_archive_location *location;
-
-			session->rotate_pending = false;
-			session->rotation_state = LTTNG_ROTATION_STATE_COMPLETED;
-			ret = rename_complete_chunk(session, now);
-			if (ret < 0) {
-				ERR("Failed to rename completed rotation chunk");
-				goto end;
-			}
-
-			/* Ownership of location is transferred. */
-			location = session_get_trace_archive_location(session);
-			ret = notification_thread_command_session_rotation_completed(
-					notification_thread_handle,
-					session->name,
-					session->uid,
-					session->gid,
-					session->current_archive_id,
-					location);
-			if (ret != LTTNG_OK) {
-				ERR("Failed to notify notification thread that rotation is complete for session %s",
-						session->name);
-			}
+		cmd_ret = ust_app_rotate_session(session);
+		if (cmd_ret != LTTNG_OK) {
+			goto error;
 		}
 	}
 
+	ret = timer_session_rotation_pending_check_start(session,
+			DEFAULT_ROTATE_PENDING_TIMER);
+	if (ret) {
+		cmd_ret = LTTNG_ERR_UNK;
+		goto error;
+	}
+
 	if (!session->active) {
 		session->rotated_after_last_stop = true;
 	}
@@ -4797,12 +4754,30 @@ int cmd_rotate_session(struct ltt_session *session,
 		rotate_return->rotation_id = session->current_archive_id;
 	}
 
-	DBG("Cmd rotate session %s, current_archive_id %" PRIu64 " sent",
-			session->name, session->current_archive_id);
-	ret = LTTNG_OK;
+	ret = notification_thread_command_session_rotation_ongoing(
+			notification_thread_handle,
+			session->name, session->uid, session->gid,
+			session->current_archive_id - 1);
+	if (ret != LTTNG_OK) {
+		ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",
+				session->name);
+		cmd_ret = ret;
+	}
 
+	DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent",
+			session->name, session->current_archive_id - 1);
 end:
+	ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret);
 	return ret;
+error:
+	session->last_chunk_start_ts = original_last_chunk_start_ts;
+	session->current_archive_id = original_current_chunk_start_ts;
+	if (session_reset_rotation_state(session,
+			LTTNG_ROTATION_STATE_NO_ROTATION)) {
+		ERR("Failed to reset rotation state of session \"%s\"",
+				session->name);
+	}
+	goto end;
 }
 
 /*
@@ -4999,14 +4974,16 @@ int cmd_rotation_set_schedule(struct ltt_session *session,
 			 * Only start the timer if the session is active,
 			 * otherwise it will be started when the session starts.
 			 */
-			ret = sessiond_rotate_timer_start(session, new_value);
+			ret = timer_session_rotation_schedule_timer_start(
+					session, new_value);
 			if (ret) {
 				ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command");
 				ret = LTTNG_ERR_UNK;
 				goto end;
 			}
 		} else {
-			ret = sessiond_rotate_timer_stop(session);
+			ret = timer_session_rotation_schedule_timer_stop(
+					session);
 			if (ret) {
 				ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command");
 				ret = LTTNG_ERR_UNK;
@@ -5047,58 +5024,6 @@ end:
 	return ret;
 }
 
-/*
- * Command ROTATE_GET_CURRENT_PATH from the lttng-ctl library.
- *
- * Configure the automatic rotation parameters.
- * Set to -1ULL to disable them.
- *
- * Return LTTNG_OK on success or else a LTTNG_ERR code.
- */
-int cmd_session_get_current_output(struct ltt_session *session,
-		struct lttng_session_get_current_output_return *output_return)
-{
-	int ret;
-	const char *path;
-
-	if (!session->snapshot_mode) {
-		if (session->current_archive_id == 0) {
-			if (session->kernel_session) {
-				path = session_get_base_path(session);
-			} else if (session->ust_session) {
-				path = session_get_base_path(session);
-			} else {
-				abort();
-			}
-			assert(path);
-		} else {
-			path = session->rotation_chunk.active_tracing_path;
-		}
-	} else {
-		/*
-		 * A snapshot session does not have a "current" trace archive
-		 * location.
-		 */
-		path = "";
-	}
-
-	DBG("Cmd get current output for session %s, returning %s",
-			session->name, path);
-
-	ret = lttng_strncpy(output_return->path,
-			path,
-			sizeof(output_return->path));
-	if (ret) {
-		ERR("Failed to copy trace output path to session get current output command reply");
-		ret = -LTTNG_ERR_UNK;
-		goto end;
-	}
-
-	ret = LTTNG_OK;
-end:
-	return ret;
-}
-
 /* Wait for a given path to be removed before continuing. */
 static enum lttng_error_code wait_on_path(void *path_data)
 {