X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=e8dfbadbf72fbc8a9edee2da53abe0f0f1990c31;hp=b76941648bd50d4a8ddafa6bc2afa8460b8e74b5;hb=d48d65e152d4a6218f6b3415486f502169bf1949;hpb=2abe796968937298012c0ec668f7fc88305683f2

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index b76941648..e8dfbadbf 100644
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -2579,11 +2579,12 @@ int cmd_start_trace(struct ltt_session *session)
 		goto error;
 	}
 
-	if (session->output_traces && !session->current_trace_chunk) {
+	if (session->output_traces && !session->current_trace_chunk &&
+			session_output_supports_trace_chunks(session)) {
 		struct lttng_trace_chunk *trace_chunk;
 
 		trace_chunk = session_create_new_trace_chunk(
-				session, NULL, NULL);
+				session, NULL, NULL, NULL);
 		if (!trace_chunk) {
 			ret = LTTNG_ERR_CREATE_DIR_FAIL;
 			goto error;
@@ -3170,8 +3171,12 @@ int cmd_destroy_session(struct ltt_session *session,
 
 	if (session->most_recent_chunk_id.is_set &&
 			session->most_recent_chunk_id.value != 0 &&
-			session->current_trace_chunk) {
-		ret = cmd_rotate_session(session, NULL);
+			session->current_trace_chunk && session->output_traces) {
+		/*
+		 * Perform a last rotation on destruction if rotations have
+		 * occurred during the session's lifetime.
+		 */
+		ret = cmd_rotate_session(session, NULL, false);
 		if (ret != LTTNG_OK) {
 			ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s",
 					session->name, lttng_strerror(-ret));
@@ -3179,7 +3184,23 @@ 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)) {
+		/*
+		 * The user has not triggered a session rotation. However, to
+		 * ensure all data has been consumed, the session is rotated
+		 * to a 'null' trace chunk before it is destroyed.
+		 *
+		 * This is a "quiet" rotation meaning that no notification is
+		 * emitted and no renaming of the current trace chunk takes
+		 * place.
+		 */
+		ret = cmd_rotate_session(session, NULL, true);
+		if (ret != LTTNG_OK) {
+			ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
+					session->name, lttng_strerror(-ret));
+		}
+	}
 
 	if (session->shm_path[0]) {
 		/*
@@ -4201,8 +4222,7 @@ end:
  * Return LTTNG_OK on success or a LTTNG_ERR code.
  */
 static enum lttng_error_code set_relayd_for_snapshot(
-		struct consumer_output *consumer,
-		const struct snapshot_output *snap_output,
+		struct consumer_output *output,
 		const struct ltt_session *session)
 {
 	enum lttng_error_code status = LTTNG_OK;
@@ -4210,17 +4230,18 @@ static enum lttng_error_code set_relayd_for_snapshot(
 	struct consumer_socket *socket;
 	LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
 
-	assert(consumer);
-	assert(snap_output);
+	assert(output);
 	assert(session);
 
 	DBG2("Set relayd object from snapshot output");
 
 	if (session->current_trace_chunk) {
-		enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id(
-				session->current_trace_chunk, &current_chunk_id.value);
+		enum lttng_trace_chunk_status chunk_status =
+				lttng_trace_chunk_get_id(
+						session->current_trace_chunk,
+						&current_chunk_id.value);
 
-		if (status == LTTNG_TRACE_CHUNK_STATUS_OK) {
+		if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) {
 			current_chunk_id.is_set = true;
 		} else {
 			ERR("Failed to get current trace chunk id");
@@ -4230,7 +4251,7 @@ static enum lttng_error_code set_relayd_for_snapshot(
 	}
 
 	/* Ignore if snapshot consumer output is not network. */
-	if (snap_output->consumer->type != CONSUMER_DST_NET) {
+	if (output->type != CONSUMER_DST_NET) {
 		goto error;
 	}
 
@@ -4239,11 +4260,11 @@ static enum lttng_error_code set_relayd_for_snapshot(
 	 * snapshot output.
 	 */
 	rcu_read_lock();
-	cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter,
+	cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
 			socket, node.node) {
 		pthread_mutex_lock(socket->lock);
 		status = send_consumer_relayd_sockets(0, session->id,
-				snap_output->consumer, socket,
+				output, socket,
 				session->name, session->hostname,
 				session->live_timer,
 				current_chunk_id.is_set ? &current_chunk_id.value : NULL,
@@ -4267,44 +4288,18 @@ error:
  */
 static enum lttng_error_code record_kernel_snapshot(
 		struct ltt_kernel_session *ksess,
-		const struct snapshot_output *output,
+		const struct consumer_output *output,
 		const struct ltt_session *session,
 		int wait, uint64_t nb_packets_per_stream)
 {
-	int ret;
 	enum lttng_error_code status;
 
 	assert(ksess);
 	assert(output);
 	assert(session);
 
-	/*
-	 * Copy kernel session sockets so we can communicate with the right
-	 * consumer for the snapshot record command.
-	 */
-	ret = consumer_copy_sockets(output->consumer, ksess->consumer);
-	if (ret < 0) {
-		status = LTTNG_ERR_NOMEM;
-		goto error;
-	}
-
-	status = set_relayd_for_snapshot(ksess->consumer, output, session);
-	if (status != LTTNG_OK) {
-		goto error_snapshot;
-	}
-
-	status = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream);
-	if (status != LTTNG_OK) {
-		goto error_snapshot;
-	}
-
-	goto end;
-
-error_snapshot:
-	/* Clean up copied sockets so this output can use some other later on. */
-	consumer_destroy_output_sockets(output->consumer);
-error:
-end:
+	status = kernel_snapshot_record(
+			ksess, output, wait, nb_packets_per_stream);
 	return status;
 }
 
@@ -4314,45 +4309,18 @@ end:
  * Returns LTTNG_OK on success or a LTTNG_ERR error code.
  */
 static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess,
-		const struct snapshot_output *output,
-		const struct ltt_session *session, int wait,
-		uint64_t nb_packets_per_stream)
+		const struct consumer_output *output,
+		const struct ltt_session *session,
+		int wait, uint64_t nb_packets_per_stream)
 {
-	int ret;
 	enum lttng_error_code status;
 
 	assert(usess);
 	assert(output);
 	assert(session);
 
-	/*
-	 * Copy UST session sockets so we can communicate with the right
-	 * consumer for the snapshot record command.
-	 */
-	ret = consumer_copy_sockets(output->consumer, usess->consumer);
-	if (ret < 0) {
-		status = LTTNG_ERR_NOMEM;
-		goto error;
-	}
-
-	status = set_relayd_for_snapshot(usess->consumer, output, session);
-	if (status != LTTNG_OK) {
-		goto error_snapshot;
-	}
-
-	status = ust_app_snapshot_record(usess, output, wait,
-			nb_packets_per_stream);
-	if (status != LTTNG_OK) {
-		goto error_snapshot;
-	}
-
-	goto end;
-
-error_snapshot:
-	/* Clean up copied sockets so this output can use some other later on. */
-	consumer_destroy_output_sockets(output->consumer);
-error:
-end:
+	status = ust_app_snapshot_record(
+			usess, output, wait, nb_packets_per_stream);
 	return status;
 }
 
@@ -4448,63 +4416,122 @@ static
 enum lttng_error_code snapshot_record(struct ltt_session *session,
 		const struct snapshot_output *snapshot_output, int wait)
 {
-	int fmt_ret;
 	int64_t nb_packets_per_stream;
 	char snapshot_chunk_name[LTTNG_NAME_MAX];
-	enum lttng_error_code ret = LTTNG_OK;
+	int ret;
+	enum lttng_error_code ret_code = LTTNG_OK;
 	struct lttng_trace_chunk *snapshot_trace_chunk;
+	struct consumer_output *original_ust_consumer_output = NULL;
+	struct consumer_output *original_kernel_consumer_output = NULL;
+	struct consumer_output *snapshot_ust_consumer_output = NULL;
+	struct consumer_output *snapshot_kernel_consumer_output = NULL;
 
-	fmt_ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name),
+	ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name),
 			"%s-%s-%" PRIu64,
 			snapshot_output->name,
 			snapshot_output->datetime,
 			snapshot_output->nb_snapshot);
-	if (fmt_ret < 0 || fmt_ret >= sizeof(snapshot_chunk_name)) {
+	if (ret < 0 || ret >= sizeof(snapshot_chunk_name)) {
 		ERR("Failed to format snapshot name");
-		ret = LTTNG_ERR_INVALID;
-		goto end;
+		ret_code = LTTNG_ERR_INVALID;
+		goto error;
 	}
 	DBG("Recording snapshot \"%s\" for session \"%s\" with chunk name \"%s\"",
 			snapshot_output->name, session->name,
 			snapshot_chunk_name);
+	if (!session->kernel_session && !session->ust_session) {
+		ERR("Failed to record snapshot as no channels exist");
+		ret_code = LTTNG_ERR_NO_CHANNEL;
+		goto error;
+	}
+
+	if (session->kernel_session) {
+		original_kernel_consumer_output =
+				session->kernel_session->consumer;
+		snapshot_kernel_consumer_output =
+				consumer_copy_output(snapshot_output->consumer);
+		ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
+				original_kernel_consumer_output);
+		if (ret < 0) {
+			ERR("Failed to copy consumer sockets from snapshot output configuration");
+			ret_code = LTTNG_ERR_NOMEM;
+			goto error;
+		}
+		ret_code = set_relayd_for_snapshot(
+				snapshot_kernel_consumer_output, session);
+		if (ret_code != LTTNG_OK) {
+			ERR("Failed to setup relay daemon for kernel tracer snapshot");
+			goto error;
+		}
+		session->kernel_session->consumer =
+				snapshot_kernel_consumer_output;
+	}
+	if (session->ust_session) {
+		original_ust_consumer_output = session->ust_session->consumer;
+		snapshot_ust_consumer_output =
+				consumer_copy_output(snapshot_output->consumer);
+		ret = consumer_copy_sockets(snapshot_ust_consumer_output,
+				original_ust_consumer_output);
+		if (ret < 0) {
+			ERR("Failed to copy consumer sockets from snapshot output configuration");
+			ret_code = LTTNG_ERR_NOMEM;
+			goto error;
+		}
+		ret_code = set_relayd_for_snapshot(
+				snapshot_ust_consumer_output, session);
+		if (ret_code != LTTNG_OK) {
+			ERR("Failed to setup relay daemon for userspace tracer snapshot");
+			goto error;
+		}
+		session->ust_session->consumer =
+				snapshot_ust_consumer_output;
+	}
+
 	snapshot_trace_chunk = session_create_new_trace_chunk(session,
-			snapshot_output_get_base_path(snapshot_output),
+			snapshot_kernel_consumer_output ?:
+					snapshot_ust_consumer_output,
+			consumer_output_get_base_path(
+					snapshot_output->consumer),
 			snapshot_chunk_name);
 	if (!snapshot_trace_chunk) {
-		ret = LTTNG_ERR_CREATE_DIR_FAIL;
-		goto end;
+		ERR("Failed to create temporary trace chunk to record a snapshot of session \"%s\"",
+				session->name);
+		ret_code = LTTNG_ERR_CREATE_DIR_FAIL;
+		goto error;
 	}
 	assert(!session->current_trace_chunk);
 	ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL);
 	lttng_trace_chunk_put(snapshot_trace_chunk);
 	snapshot_trace_chunk = NULL;
 	if (ret) {
-		ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
-		goto end;
+		ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"",
+				session->name);
+		ret_code = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
+		goto error;
 	}
 
 	nb_packets_per_stream = get_session_nb_packets_per_stream(session,
 			snapshot_output->max_size);
 	if (nb_packets_per_stream < 0) {
-		ret = LTTNG_ERR_MAX_SIZE_INVALID;
-		goto end;
+		ret_code = LTTNG_ERR_MAX_SIZE_INVALID;
+		goto error;
 	}
 
 	if (session->kernel_session) {
-		ret = record_kernel_snapshot(session->kernel_session,
-				snapshot_output, session,
+		ret_code = record_kernel_snapshot(session->kernel_session,
+				snapshot_kernel_consumer_output, session,
 				wait, nb_packets_per_stream);
-		if (ret != LTTNG_OK) {
-			goto end;
+		if (ret_code != LTTNG_OK) {
+			goto error;
 		}
 	}
 
 	if (session->ust_session) {
-		ret = record_ust_snapshot(session->ust_session,
-				snapshot_output, session,
+		ret_code = record_ust_snapshot(session->ust_session,
+				snapshot_ust_consumer_output, session,
 				wait, nb_packets_per_stream);
-		if (ret != LTTNG_OK) {
-			goto end;
+		if (ret_code != LTTNG_OK) {
+			goto error;
 		}
 	}
 
@@ -4516,15 +4543,24 @@ enum lttng_error_code snapshot_record(struct ltt_session *session,
 		 */
 		ERR("Failed to close snapshot trace chunk of session \"%s\"",
 				session->name);
-		ret = -1;
+		ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
 	}
 	if (session_set_trace_chunk(session, NULL, NULL)) {
 		ERR("Failed to release the current trace chunk of session \"%s\"",
 				session->name);
-		ret = -1;
+		ret_code = LTTNG_ERR_UNK;
 	}
-end:
-	return ret;
+error:
+	if (original_ust_consumer_output) {
+		session->ust_session->consumer = original_ust_consumer_output;
+	}
+	if (original_kernel_consumer_output) {
+		session->kernel_session->consumer =
+				original_kernel_consumer_output;
+	}
+	consumer_output_put(snapshot_ust_consumer_output);
+	consumer_output_put(snapshot_kernel_consumer_output);
+	return ret_code;
 }
 
 /*
@@ -4693,7 +4729,8 @@ int cmd_set_session_shm_path(struct ltt_session *session,
  * 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)
+		struct lttng_rotate_session_return *rotate_return,
+		bool quiet_rotation)
 {
 	int ret;
 	uint64_t ongoing_rotation_chunk_id;
@@ -4709,7 +4746,14 @@ int cmd_rotate_session(struct ltt_session *session,
 		goto end;
 	}
 
-	if (session->live_timer || !session->output_traces) {
+	/*
+	 * Explicit rotation is not supported for live sessions.
+	 * However, live sessions can perform a quiet rotation on
+	 * destroy.
+	 * Rotation is not supported for snapshot traces (no output).
+	 */
+	if ((!quiet_rotation && session->live_timer) ||
+			!session->output_traces) {
 		cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
 		goto end;
 	}
@@ -4743,7 +4787,7 @@ int cmd_rotate_session(struct ltt_session *session,
 	session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
 
 	if (session->active) {
-		new_trace_chunk = session_create_new_trace_chunk(session,
+		new_trace_chunk = session_create_new_trace_chunk(session, NULL,
 				NULL, NULL);
 		if (!new_trace_chunk) {
 			cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
@@ -4778,13 +4822,16 @@ int cmd_rotate_session(struct ltt_session *session,
 	}
 
 	ret = session_close_trace_chunk(session, chunk_being_archived,
-			&((enum lttng_trace_chunk_command_type) {
-					LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}));
+			quiet_rotation ?
+					NULL :
+					&((enum lttng_trace_chunk_command_type){
+							LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}));
 	if (ret) {
 		cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
 		goto error;
 	}
 
+	session->quiet_rotation = quiet_rotation;
 	ret = timer_session_rotation_pending_check_start(session,
 			DEFAULT_ROTATE_PENDING_TIMER);
 	if (ret) {
@@ -4802,14 +4849,16 @@ int cmd_rotate_session(struct ltt_session *session,
 
 	session->chunk_being_archived = chunk_being_archived;
 	chunk_being_archived = NULL;
-	ret = notification_thread_command_session_rotation_ongoing(
-			notification_thread_handle,
-			session->name, session->uid, session->gid,
-			ongoing_rotation_chunk_id);
-	if (ret != LTTNG_OK) {
-		ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",
-				session->name);
-		cmd_ret = ret;
+	if (!quiet_rotation) {
+		ret = notification_thread_command_session_rotation_ongoing(
+				notification_thread_handle,
+				session->name, session->uid, session->gid,
+				ongoing_rotation_chunk_id);
+		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",