X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=2c2ce285a676461238703f2cb77a285cdb5a66b6;hb=875b29bfdafecb38a552264b0775478eaef0cae1;hp=5a122d8d3c8dcf7e7f361b34f69f46c4680c0d22;hpb=1f4962443f25c371e4b54e97f9eb867d67cbf88e;p=lttng-tools.git

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index 5a122d8d3..2c2ce285a 100644
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -998,6 +998,8 @@ static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri,
 
 	/* Create socket for control stream. */
 	if (uri->stype == LTTNG_STREAM_CONTROL) {
+		uint64_t result_flags;
+
 		DBG3("Creating relayd stream socket from URI");
 
 		/* Check relayd version */
@@ -1012,6 +1014,16 @@ static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri,
 		}
 		consumer->relay_major_version = rsock->major;
 		consumer->relay_minor_version = rsock->minor;
+		ret = relayd_get_configuration(rsock, 0,
+				&result_flags);
+		if (ret < 0) {
+			ERR("Unable to get relayd configuration");
+			status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
+			goto close_sock;
+		}
+		if (result_flags & LTTCOMM_RELAYD_CONFIGURATION_FLAG_CLEAR_ALLOWED) {
+			consumer->relay_allows_clear = true;
+		}
 	} else if (uri->stype == LTTNG_STREAM_DATA) {
 		DBG3("Creating relayd data socket from URI");
 	} else {
@@ -1185,6 +1197,7 @@ int cmd_setup_relayd(struct ltt_session *session)
 
 	DBG("Setting relayd for session %s", session->name);
 
+	rcu_read_lock();
 	if (session->current_trace_chunk) {
 		enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id(
 				session->current_trace_chunk, &current_chunk_id.value);
@@ -1198,8 +1211,6 @@ int cmd_setup_relayd(struct ltt_session *session)
 		}
 	}
 
-	rcu_read_lock();
-
 	if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
 			&& usess->consumer->enabled) {
 		/* For each consumer socket, send relayd sockets */
@@ -1225,6 +1236,8 @@ int cmd_setup_relayd(struct ltt_session *session)
 			usess->consumer->relay_major_version;
 		session->consumer->relay_minor_version =
 			usess->consumer->relay_minor_version;
+		session->consumer->relay_allows_clear =
+			usess->consumer->relay_allows_clear;
 	}
 
 	if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
@@ -1251,6 +1264,8 @@ int cmd_setup_relayd(struct ltt_session *session)
 			ksess->consumer->relay_major_version;
 		session->consumer->relay_minor_version =
 			ksess->consumer->relay_minor_version;
+		session->consumer->relay_allows_clear =
+			ksess->consumer->relay_allows_clear;
 	}
 
 error:
@@ -1261,7 +1276,7 @@ error:
 /*
  * Start a kernel session by opening all necessary streams.
  */
-static int start_kernel_session(struct ltt_kernel_session *ksess)
+int start_kernel_session(struct ltt_kernel_session *ksess)
 {
 	int ret;
 	struct ltt_kernel_channel *kchan;
@@ -1323,6 +1338,53 @@ error:
 	return ret;
 }
 
+int stop_kernel_session(struct ltt_kernel_session *ksess)
+{
+	struct ltt_kernel_channel *kchan;
+	bool error_occurred = false;
+	int ret;
+
+	if (!ksess || !ksess->active) {
+		return LTTNG_OK;
+	}
+	DBG("Stopping kernel tracing");
+
+	ret = kernel_stop_session(ksess);
+	if (ret < 0) {
+		ret = LTTNG_ERR_KERN_STOP_FAIL;
+		goto error;
+	}
+
+	kernel_wait_quiescent();
+
+	/* Flush metadata after stopping (if exists) */
+	if (ksess->metadata_stream_fd >= 0) {
+		ret = kernel_metadata_flush_buffer(ksess->metadata_stream_fd);
+		if (ret < 0) {
+			ERR("Kernel metadata flush failed");
+			error_occurred = true;
+		}
+	}
+
+	/* Flush all buffers after stopping */
+	cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
+		ret = kernel_flush_buffer(kchan);
+		if (ret < 0) {
+			ERR("Kernel flush buffer error");
+			error_occurred = true;
+		}
+	}
+
+	ksess->active = 0;
+	if (error_occurred) {
+		ret = LTTNG_ERR_UNK;
+	} else {
+		ret = LTTNG_OK;
+	}
+error:
+	return ret;
+}
+
 /*
  * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
  */
@@ -1380,12 +1442,14 @@ error:
 }
 
 /*
- * Command LTTNG_TRACK_PID processed by the client thread.
+ * Command LTTNG_TRACK_ID processed by the client thread.
  *
  * Called with session lock held.
  */
-int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
-		int pid)
+int cmd_track_id(struct ltt_session *session,
+		enum lttng_tracker_type tracker_type,
+		enum lttng_domain_type domain,
+		const struct lttng_tracker_id *id)
 {
 	int ret;
 
@@ -1398,7 +1462,7 @@ int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
 
 		ksess = session->kernel_session;
 
-		ret = kernel_track_pid(ksess, pid);
+		ret = kernel_track_id(tracker_type, ksess, id);
 		if (ret != LTTNG_OK) {
 			goto error;
 		}
@@ -1412,7 +1476,7 @@ int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
 
 		usess = session->ust_session;
 
-		ret = trace_ust_track_pid(usess, pid);
+		ret = trace_ust_track_id(tracker_type, usess, id);
 		if (ret != LTTNG_OK) {
 			goto error;
 		}
@@ -1431,12 +1495,14 @@ error:
 }
 
 /*
- * Command LTTNG_UNTRACK_PID processed by the client thread.
+ * Command LTTNG_UNTRACK_ID processed by the client thread.
  *
  * Called with session lock held.
  */
-int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
-		int pid)
+int cmd_untrack_id(struct ltt_session *session,
+		enum lttng_tracker_type tracker_type,
+		enum lttng_domain_type domain,
+		const struct lttng_tracker_id *id)
 {
 	int ret;
 
@@ -1449,7 +1515,7 @@ int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
 
 		ksess = session->kernel_session;
 
-		ret = kernel_untrack_pid(ksess, pid);
+		ret = kernel_untrack_id(tracker_type, ksess, id);
 		if (ret != LTTNG_OK) {
 			goto error;
 		}
@@ -1463,7 +1529,7 @@ int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
 
 		usess = session->ust_session;
 
-		ret = trace_ust_untrack_pid(usess, pid);
+		ret = trace_ust_untrack_id(tracker_type, usess, id);
 		if (ret != LTTNG_OK) {
 			goto error;
 		}
@@ -2511,15 +2577,16 @@ ssize_t cmd_list_syscalls(struct lttng_event **events)
 }
 
 /*
- * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread.
+ * Command LTTNG_LIST_TRACKER_IDS processed by the client thread.
  *
  * Called with session lock held.
  */
-ssize_t cmd_list_tracker_pids(struct ltt_session *session,
-		enum lttng_domain_type domain, int32_t **pids)
+int cmd_list_tracker_ids(enum lttng_tracker_type tracker_type,
+		struct ltt_session *session,
+		enum lttng_domain_type domain,
+		struct lttng_tracker_ids **ids)
 {
-	int ret;
-	ssize_t nr_pids = 0;
+	int ret = LTTNG_OK;
 
 	switch (domain) {
 	case LTTNG_DOMAIN_KERNEL:
@@ -2527,9 +2594,9 @@ ssize_t cmd_list_tracker_pids(struct ltt_session *session,
 		struct ltt_kernel_session *ksess;
 
 		ksess = session->kernel_session;
-		nr_pids = kernel_list_tracker_pids(ksess, pids);
-		if (nr_pids < 0) {
-			ret = LTTNG_ERR_KERN_LIST_FAIL;
+		ret = kernel_list_tracker_ids(tracker_type, ksess, ids);
+		if (ret != LTTNG_OK) {
+			ret = -LTTNG_ERR_KERN_LIST_FAIL;
 			goto error;
 		}
 		break;
@@ -2539,9 +2606,9 @@ ssize_t cmd_list_tracker_pids(struct ltt_session *session,
 		struct ltt_ust_session *usess;
 
 		usess = session->ust_session;
-		nr_pids = trace_ust_list_tracker_pids(usess, pids);
-		if (nr_pids < 0) {
-			ret = LTTNG_ERR_UST_LIST_FAIL;
+		ret = trace_ust_list_tracker_ids(tracker_type, usess, ids);
+		if (ret != LTTNG_OK) {
+			ret = -LTTNG_ERR_UST_LIST_FAIL;
 			goto error;
 		}
 		break;
@@ -2550,15 +2617,13 @@ ssize_t cmd_list_tracker_pids(struct ltt_session *session,
 	case LTTNG_DOMAIN_JUL:
 	case LTTNG_DOMAIN_PYTHON:
 	default:
-		ret = LTTNG_ERR_UND;
+		ret = -LTTNG_ERR_UND;
 		goto error;
 	}
 
-	return nr_pids;
-
 error:
 	/* Return negative value to differentiate return code */
-	return -ret;
+	return ret;
 }
 
 /*
@@ -2574,6 +2639,8 @@ int cmd_start_trace(struct ltt_session *session)
 	struct ltt_ust_session *usess;
 	const bool session_rotated_after_last_stop =
 			session->rotated_after_last_stop;
+	const bool session_cleared_after_last_stop =
+			session->cleared_after_last_stop;
 
 	assert(session);
 
@@ -2584,7 +2651,8 @@ int cmd_start_trace(struct ltt_session *session)
 	/* Is the session already started? */
 	if (session->active) {
 		ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
-		goto error;
+		/* Perform nothing */
+		goto end;
 	}
 
 	if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING &&
@@ -2620,6 +2688,7 @@ int cmd_start_trace(struct ltt_session *session)
 
 	session->active = 1;
 	session->rotated_after_last_stop = false;
+	session->cleared_after_last_stop = false;
 	if (session->output_traces && !session->current_trace_chunk) {
 		if (!session->has_been_started) {
 			struct lttng_trace_chunk *trace_chunk;
@@ -2653,7 +2722,8 @@ int cmd_start_trace(struct ltt_session *session)
 			 * was produced as the session was stopped, so the
 			 * rotation should happen on reception of the command.
 			 */
-			ret = cmd_rotate_session(session, NULL, true);
+			ret = cmd_rotate_session(session, NULL, true,
+					LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
 			if (ret != LTTNG_OK) {
 				goto error;
 			}
@@ -2707,7 +2777,10 @@ error:
 		/* Restore initial state on error. */
 		session->rotated_after_last_stop =
 				session_rotated_after_last_stop;
+		session->cleared_after_last_stop =
+				session_cleared_after_last_stop;
 	}
+end:
 	return ret;
 }
 
@@ -2717,14 +2790,12 @@ error:
 int cmd_stop_trace(struct ltt_session *session)
 {
 	int ret;
-	struct ltt_kernel_channel *kchan;
 	struct ltt_kernel_session *ksession;
 	struct ltt_ust_session *usess;
-	bool error_occurred = false;
 
 	assert(session);
 
-	DBG("Begin stop session %s (id %" PRIu64 ")", session->name, session->id);
+	DBG("Begin stop session \"%s\" (id %" PRIu64 ")", session->name, session->id);
 	/* Short cut */
 	ksession = session->kernel_session;
 	usess = session->ust_session;
@@ -2735,39 +2806,9 @@ int cmd_stop_trace(struct ltt_session *session)
 		goto error;
 	}
 
-	/* Kernel tracer */
-	if (ksession && ksession->active) {
-		DBG("Stop kernel tracing");
-
-		ret = kernel_stop_session(ksession);
-		if (ret < 0) {
-			ret = LTTNG_ERR_KERN_STOP_FAIL;
-			goto error;
-		}
-
-		kernel_wait_quiescent();
-
-		/* Flush metadata after stopping (if exists) */
-		if (ksession->metadata_stream_fd >= 0) {
-			ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
-			if (ret < 0) {
-				ERR("Kernel metadata flush failed");
-				error_occurred = true;
-			}
-		}
-
-		/* Flush all buffers after stopping */
-		cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
-			ret = kernel_flush_buffer(kchan);
-			if (ret < 0) {
-				ERR("Kernel flush buffer error");
-				error_occurred = true;
-			}
-		}
-
-		ksession->active = 0;
-		DBG("Kernel session stopped %s (id %" PRIu64 ")", session->name,
-				session->id);
+	ret = stop_kernel_session(ksession);
+	if (ret != LTTNG_OK) {
+		goto error;
 	}
 
 	if (usess && usess->active) {
@@ -2778,9 +2819,11 @@ int cmd_stop_trace(struct ltt_session *session)
 		}
 	}
 
+	DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name,
+			session->id);
 	/* Flag inactive after a successful stop. */
 	session->active = 0;
-	ret = !error_occurred ? LTTNG_OK : LTTNG_ERR_UNK;
+	ret = LTTNG_OK;
 
 error:
 	return ret;
@@ -3290,14 +3333,13 @@ int cmd_destroy_session(struct ltt_session *session,
 		session->rotate_size = 0;
 	}
 
-	if (session->most_recent_chunk_id.is_set &&
-			session->most_recent_chunk_id.value != 0 &&
-			session->current_trace_chunk && session->output_traces) {
+	if (session->rotated && 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);
+		ret = cmd_rotate_session(session, NULL, false,
+			LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
 		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));
@@ -3316,7 +3358,8 @@ int cmd_destroy_session(struct ltt_session *session,
 		 * emitted and no renaming of the current trace chunk takes
 		 * place.
 		 */
-		ret = cmd_rotate_session(session, NULL, true);
+		ret = cmd_rotate_session(session, NULL, true,
+			LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
 		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));
@@ -4675,8 +4718,14 @@ enum lttng_error_code snapshot_record(struct ltt_session *session,
 		}
 	}
 
-	if (session_close_trace_chunk(
-			    session, session->current_trace_chunk, NULL, NULL)) {
+	if (session_set_trace_chunk(session, NULL, &snapshot_trace_chunk)) {
+		ERR("Failed to release the current trace chunk of session \"%s\"",
+				session->name);
+		ret_code = LTTNG_ERR_UNK;
+	}
+
+	if (session_close_trace_chunk(session, snapshot_trace_chunk,
+			LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION, NULL)) {
 		/*
 		 * Don't goto end; make sure the chunk is closed for the session
 		 * to allow future snapshots.
@@ -4685,11 +4734,6 @@ enum lttng_error_code snapshot_record(struct ltt_session *session,
 				session->name);
 		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_code = LTTNG_ERR_UNK;
-	}
 error:
 	if (original_ust_consumer_output) {
 		session->ust_session->consumer = original_ust_consumer_output;
@@ -4870,7 +4914,8 @@ int cmd_set_session_shm_path(struct ltt_session *session,
  */
 int cmd_rotate_session(struct ltt_session *session,
 		struct lttng_rotate_session_return *rotate_return,
-		bool quiet_rotation)
+		bool quiet_rotation,
+		enum lttng_trace_chunk_command_type command)
 {
 	int ret;
 	uint64_t ongoing_rotation_chunk_id;
@@ -4908,6 +4953,12 @@ int cmd_rotate_session(struct ltt_session *session,
 		goto end;
 	}
 
+	/* Unsupported feature in lttng-modules before 2.8 (lack of sequence number). */
+	if (session->kernel_session && !kernel_supports_ring_buffer_packet_sequence_number()) {
+		cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL;
+		goto end;
+	}
+
 	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);
@@ -4926,7 +4977,16 @@ int cmd_rotate_session(struct ltt_session *session,
 		goto end;
 	}
 
-	session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
+	/*
+	 * After a stop followed by a clear, disallow following rotations a they would
+	 * generate empty chunks.
+	 */
+	if (session->cleared_after_last_stop) {
+		DBG("Session \"%s\" was already cleared after stop, refusing rotation",
+				session->name);
+		cmd_ret = LTTNG_ERR_ROTATION_AFTER_STOP_CLEAR;
+		goto end;
+	}
 
 	if (session->active) {
 		new_trace_chunk = session_create_new_trace_chunk(session, NULL,
@@ -4951,11 +5011,6 @@ int cmd_rotate_session(struct ltt_session *session,
 		goto error;
 	}
 
-	assert(chunk_being_archived);
-	chunk_status = lttng_trace_chunk_get_id(chunk_being_archived,
-			&ongoing_rotation_chunk_id);
-	assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
-
 	if (session->kernel_session) {
 		cmd_ret = kernel_rotate_session(session);
 		if (cmd_ret != LTTNG_OK) {
@@ -4971,12 +5026,28 @@ int cmd_rotate_session(struct ltt_session *session,
 		}
 	}
 
+	if (!session->active) {
+		session->rotated_after_last_stop = true;
+	}
+
+	if (!chunk_being_archived) {
+		DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check",
+				session->name);
+		if (failed_to_rotate) {
+			cmd_ret = rotation_fail_code;
+			goto error;
+		}
+		cmd_ret = LTTNG_OK;
+		goto end;
+	}
+
+	session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
+	chunk_status = lttng_trace_chunk_get_id(chunk_being_archived,
+			&ongoing_rotation_chunk_id);
+	assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
+
 	ret = session_close_trace_chunk(session, chunk_being_archived,
-			quiet_rotation ?
-					NULL :
-					&((enum lttng_trace_chunk_command_type){
-							LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}),
-			session->last_chunk_path);
+		command, session->last_chunk_path);
 	if (ret) {
 		cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
 		goto error;
@@ -4995,10 +5066,6 @@ int cmd_rotate_session(struct ltt_session *session,
 		goto error;
 	}
 
-	if (!session->active) {
-		session->rotated_after_last_stop = true;
-	}
-
 	if (rotate_return) {
 		rotate_return->rotation_id = ongoing_rotation_chunk_id;
 	}