X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=cfe4371186447a1bbe51f8676e59550c7b7efcf3;hp=f50ca306145f9b30e28b24f3bfea500f9181f1f4;hb=e283e4a062cc16b5839a8a479e12498789320b5e;hpb=6a0838b7bdcc04613f703dc6580f81beb849fa64

diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c
index f50ca3061..cfe437118 100644
--- a/src/lib/lttng-ctl/lttng-ctl.c
+++ b/src/lib/lttng-ctl/lttng-ctl.c
@@ -45,6 +45,8 @@
 #include <lttng/userspace-probe-internal.h>
 #include <lttng/session-internal.h>
 #include <lttng/session-descriptor-internal.h>
+#include <lttng/destruction-handle.h>
+#include <lttng/tracker-internal.h>
 
 #include "filter/filter-ast.h"
 #include "filter/filter-parser.h"
@@ -66,9 +68,16 @@ do {								\
 } while (0)
 #endif
 
+#define COPY_DOMAIN_PACKED(dst, src)				\
+do {								\
+	struct lttng_domain _tmp_domain;			\
+								\
+	lttng_ctl_copy_lttng_domain(&_tmp_domain, &src);	\
+	dst = _tmp_domain;					\
+} while (0)
 
 /* Socket to session daemon for communication */
-static int sessiond_socket;
+static int sessiond_socket = -1;
 static char sessiond_sock_path[PATH_MAX];
 
 /* Variables */
@@ -423,17 +432,12 @@ error:
 /*
  * Connect to the LTTng session daemon.
  *
- * On success, return 0. On error, return -1.
+ * On success, return the socket's file descriptor. On error, return -1.
  */
-static int connect_sessiond(void)
+LTTNG_HIDDEN int connect_sessiond(void)
 {
 	int ret;
 
-	/* Don't try to connect if already connected. */
-	if (connected) {
-		return 0;
-	}
-
 	ret = set_session_daemon_path();
 	if (ret < 0) {
 		goto error;
@@ -445,15 +449,18 @@ static int connect_sessiond(void)
 		goto error;
 	}
 
-	sessiond_socket = ret;
-	connected = 1;
-
-	return 0;
+	return ret;
 
 error:
 	return -1;
 }
 
+static void reset_global_sessiond_connection_state(void)
+{
+	sessiond_socket = -1;
+	connected = 0;
+}
+
 /*
  *  Clean disconnect from the session daemon.
  *
@@ -465,8 +472,7 @@ static int disconnect_sessiond(void)
 
 	if (connected) {
 		ret = lttcomm_close_unix_sock(sessiond_socket);
-		sessiond_socket = 0;
-		connected = 0;
+		reset_global_sessiond_connection_state();
 	}
 
 	return ret;
@@ -541,6 +547,9 @@ int lttng_ctl_ask_sessiond_fds_varlen(struct lttcomm_session_msg *lsm,
 	if (ret < 0) {
 		ret = -LTTNG_ERR_NO_SESSIOND;
 		goto end;
+	} else {
+		sessiond_socket = ret;
+		connected = 1;
 	}
 
 	/* Send command to session daemon */
@@ -652,7 +661,7 @@ int lttng_register_consumer(struct lttng_handle *handle,
 	lsm.cmd_type = LTTNG_REGISTER_CONSUMER;
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	lttng_ctl_copy_string(lsm.u.reg.path, socket_path,
 			sizeof(lsm.u.reg.path));
@@ -723,7 +732,7 @@ static int _lttng_stop_tracing(const char *session_name, int wait)
 		 * call returned value indicates availability.
 		 */
 		if (data_ret) {
-			usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
+			usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME_US);
 		}
 	} while (data_ret != 0);
 
@@ -783,7 +792,7 @@ int lttng_add_context(struct lttng_handle *handle,
 				sizeof(lsm.u.context.channel_name));
 	}
 
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
 
@@ -1123,8 +1132,7 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
 		lttng_ctl_copy_string(ev->name, "*", sizeof(ev->name));
 	}
 
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-	/* FIXME: copying non-packed struct to packed struct. */
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 	memcpy(&lsm.u.enable.event, ev, sizeof(lsm.u.enable.event));
 
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
@@ -1317,8 +1325,7 @@ int lttng_disable_event_ext(struct lttng_handle *handle,
 
 	lsm.cmd_type = LTTNG_DISABLE_EVENT;
 
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-	/* FIXME: copying non-packed struct to packed struct. */
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 	memcpy(&lsm.u.disable.event, ev, sizeof(lsm.u.disable.event));
 
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
@@ -1564,7 +1571,7 @@ int lttng_enable_channel(struct lttng_handle *handle,
 	}
 
 	lsm.cmd_type = LTTNG_ENABLE_CHANNEL;
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
@@ -1592,59 +1599,7 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name)
 	lttng_ctl_copy_string(lsm.u.disable.channel_name, name,
 			sizeof(lsm.u.disable.channel_name));
 
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
-			sizeof(lsm.session.name));
-
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
-}
-
-/*
- * Add PID to session tracker.
- * Return 0 on success else a negative LTTng error code.
- */
-int lttng_track_pid(struct lttng_handle *handle, int pid)
-{
-	struct lttcomm_session_msg lsm;
-
-	/* NULL arguments are forbidden. No default values. */
-	if (handle == NULL) {
-		return -LTTNG_ERR_INVALID;
-	}
-
-	memset(&lsm, 0, sizeof(lsm));
-
-	lsm.cmd_type = LTTNG_TRACK_PID;
-	lsm.u.pid_tracker.pid = pid;
-
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
-			sizeof(lsm.session.name));
-
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
-}
-
-/*
- * Remove PID from session tracker.
- * Return 0 on success else a negative LTTng error code.
- */
-int lttng_untrack_pid(struct lttng_handle *handle, int pid)
-{
-	struct lttcomm_session_msg lsm;
-
-	/* NULL arguments are forbidden. No default values. */
-	if (handle == NULL) {
-		return -LTTNG_ERR_INVALID;
-	}
-
-	memset(&lsm, 0, sizeof(lsm));
-
-	lsm.cmd_type = LTTNG_UNTRACK_PID;
-	lsm.u.pid_tracker.pid = pid;
-
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
@@ -1670,7 +1625,7 @@ int lttng_list_tracepoints(struct lttng_handle *handle,
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_LIST_TRACEPOINTS;
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	ret = lttng_ctl_ask_sessiond(&lsm, (void **) events);
 	if (ret < 0) {
@@ -1698,7 +1653,7 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle,
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS;
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	ret = lttng_ctl_ask_sessiond(&lsm, (void **) fields);
 	if (ret < 0) {
@@ -1830,7 +1785,7 @@ end:
 /*
  * Create a new session using name and url for destination.
  *
- * Returns LTTNG_OK on success or a negative error code.
+ * Return 0 on success else a negative LTTng error code.
  */
 int lttng_create_session(const char *name, const char *url)
 {
@@ -1885,7 +1840,7 @@ end:
 /*
  * Create a session exclusively used for snapshot.
  *
- * Returns LTTNG_OK on success or a negative error code.
+ * Return 0 on success else a negative LTTng error code.
  */
 int lttng_create_session_snapshot(const char *name, const char *snapshot_url)
 {
@@ -1961,7 +1916,7 @@ end:
 /*
  * Create a session exclusively used for live.
  *
- * Returns LTTNG_OK on success or a negative error code.
+ * Return 0 on success else a negative LTTng error code.
  */
 int lttng_create_session_live(const char *name, const char *url,
 		unsigned int timer_interval)
@@ -1993,45 +1948,49 @@ end:
 	return ret;
 }
 
-/*
- * Destroy session using name.
- * Returns size of returned session payload data or a negative error code.
- */
-static
-int _lttng_destroy_session(const char *session_name)
-{
-	struct lttcomm_session_msg lsm;
-
-	if (session_name == NULL) {
-		return -LTTNG_ERR_INVALID;
-	}
-
-	memset(&lsm, 0, sizeof(lsm));
-	lsm.cmd_type = LTTNG_DESTROY_SESSION;
-
-	lttng_ctl_copy_string(lsm.session.name, session_name,
-			sizeof(lsm.session.name));
-
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
-}
-
 /*
  * Stop the session and wait for the data before destroying it
+ *
+ * Return 0 on success else a negative LTTng error code.
  */
 int lttng_destroy_session(const char *session_name)
 {
 	int ret;
+	enum lttng_error_code ret_code;
+	enum lttng_destruction_handle_status status;
+	struct lttng_destruction_handle *handle = NULL;
 
 	/*
-	 * Stop the tracing and wait for the data.
+	 * Stop the tracing and wait for the data to be
+	 * consumed.
 	 */
 	ret = _lttng_stop_tracing(session_name, 1);
 	if (ret && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
 		goto end;
 	}
 
-	ret = _lttng_destroy_session(session_name);
+	ret_code = lttng_destroy_session_ext(session_name, &handle);
+	if (ret_code != LTTNG_OK) {
+		ret = (int) -ret_code;
+		goto end;
+	}
+	assert(handle);
+
+	/* Block until the completion of the destruction of the session. */
+	status = lttng_destruction_handle_wait_for_completion(handle, -1);
+	if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED) {
+		ret = -LTTNG_ERR_UNK;
+		goto end;
+	}
+
+	status = lttng_destruction_handle_get_result(handle, &ret_code);
+	if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
+		ret = -LTTNG_ERR_UNK;
+		goto end;
+	}
+	ret = ret_code == LTTNG_OK ? 0 : -ret_code;
 end:
+	lttng_destruction_handle_destroy(handle);
 	return ret;
 }
 
@@ -2040,21 +1999,10 @@ end:
  */
 int lttng_destroy_session_no_wait(const char *session_name)
 {
-	int ret;
-
-	/*
-	 * Stop the tracing without waiting for the data.
-	 * The session might already have been stopped, so just
-	 * skip this error.
-	 */
-	ret = _lttng_stop_tracing(session_name, 0);
-	if (ret && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
-		goto end;
-	}
+	enum lttng_error_code ret_code;
 
-	ret = _lttng_destroy_session(session_name);
-end:
-	return ret;
+	ret_code = lttng_destroy_session_ext(session_name, NULL);
+	return ret_code == LTTNG_OK ? ret_code : -ret_code;
 }
 
 /*
@@ -2077,7 +2025,6 @@ int lttng_list_sessions(struct lttng_session **out_sessions)
 	lsm.cmd_type = LTTNG_LIST_SESSIONS;
 	ret = lttng_ctl_ask_sessiond(&lsm, (void**) &sessions);
 	if (ret <= 0) {
-		ret = ret == 0 ? -LTTNG_ERR_FATAL : ret;
 		goto end;
 	}
 	if (!sessions) {
@@ -2208,7 +2155,7 @@ int lttng_list_channels(struct lttng_handle *handle,
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
 
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	ret = lttng_ctl_ask_sessiond(&lsm, (void**) channels);
 	if (ret < 0) {
@@ -2268,7 +2215,7 @@ int lttng_list_events(struct lttng_handle *handle,
 			sizeof(lsm.session.name));
 	lttng_ctl_copy_string(lsm.u.list.channel_name, channel_name,
 			sizeof(lsm.u.list.channel_name));
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm, NULL, 0, NULL, 0,
 		(void **) &reception_buffer, (void **) &cmd_header,
@@ -2285,7 +2232,7 @@ int lttng_list_events(struct lttng_handle *handle,
 	/* Set number of events and free command header */
 	nb_events = cmd_header->nb_events;
 	if (nb_events > INT_MAX) {
-		ret = -EOVERFLOW;
+		ret = -LTTNG_ERR_OVERFLOW;
 		goto end;
 	}
 	free(cmd_header);
@@ -2795,7 +2742,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
 
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	size = uri_parse_str_urls(control_url, data_url, &uris);
 	if (size < 0) {
@@ -2814,6 +2761,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
 /*
  * [OBSOLETE]
  */
+int lttng_enable_consumer(struct lttng_handle *handle);
 int lttng_enable_consumer(struct lttng_handle *handle)
 {
 	return -ENOSYS;
@@ -2822,6 +2770,7 @@ int lttng_enable_consumer(struct lttng_handle *handle)
 /*
  * [OBSOLETE]
  */
+int lttng_disable_consumer(struct lttng_handle *handle);
 int lttng_disable_consumer(struct lttng_handle *handle)
 {
 	return -ENOSYS;
@@ -2830,6 +2779,8 @@ int lttng_disable_consumer(struct lttng_handle *handle)
 /*
  * [OBSOLETE]
  */
+int _lttng_create_session_ext(const char *name, const char *url,
+		const char *datetime);
 int _lttng_create_session_ext(const char *name, const char *url,
 		const char *datetime)
 {
@@ -2864,6 +2815,10 @@ int lttng_data_pending(const char *session_name)
 		/* Unexpected payload size */
 		ret = -LTTNG_ERR_INVALID;
 		goto end;
+	} else if (!pending) {
+		/* Internal error. */
+		ret = -LTTNG_ERR_UNK;
+		goto end;
 	}
 
 	ret = (int) *pending;
@@ -2873,52 +2828,169 @@ end:
 }
 
 /*
- * List PIDs in the tracker.
+ * List IDs in the tracker.
  *
- * enabled is set to whether the PID tracker is enabled.
- * pids is set to an allocated array of PIDs currently tracked. On
- * success, pids must be freed by the caller.
- * nr_pids is set to the number of entries contained by the pids array.
+ * tracker_type is the type of tracker.
+ * ids is set to an allocated array of IDs currently tracked. On
+ * success, ids and contained ids must be freed/destroy by the caller.
+ * nr_ids is set to the number of entries contained by the ids array.
  *
  * Returns 0 on success, else a negative LTTng error code.
  */
-int lttng_list_tracker_pids(struct lttng_handle *handle,
-		int *_enabled, int32_t **_pids, size_t *_nr_pids)
+int lttng_list_tracker_ids(struct lttng_handle *handle,
+		enum lttng_tracker_type tracker_type,
+		struct lttng_tracker_ids **_ids)
 {
-	int ret;
-	int enabled = 1;
+	int ret, i;
 	struct lttcomm_session_msg lsm;
-	size_t nr_pids;
-	int32_t *pids = NULL;
+	struct lttcomm_tracker_command_header *cmd_header = NULL;
+	char *cmd_payload = NULL, *p;
+	size_t cmd_header_len;
+	size_t nr_ids = 0;
+	struct lttng_tracker_ids *ids = NULL;
 
 	if (handle == NULL) {
 		return -LTTNG_ERR_INVALID;
 	}
 
 	memset(&lsm, 0, sizeof(lsm));
-	lsm.cmd_type = LTTNG_LIST_TRACKER_PIDS;
+	lsm.cmd_type = LTTNG_LIST_TRACKER_IDS;
+	lsm.u.id_tracker_list.tracker_type = tracker_type;
 	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
-	lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
+
+	ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm, NULL, 0, NULL, 0,
+			(void **) &cmd_payload, (void **) &cmd_header,
+			&cmd_header_len);
+	if (ret < 0) {
+		goto error;
+	}
+
+	/* Set number of tracker_id and free command header */
+	nr_ids = cmd_header->nb_tracker_id;
+	if (nr_ids > INT_MAX) {
+		ret = -LTTNG_ERR_OVERFLOW;
+		goto error;
+	}
+	free(cmd_header);
+	cmd_header = NULL;
+
+	ids = lttng_tracker_ids_create(nr_ids);
+	if (!ids) {
+		ret = -LTTNG_ERR_NOMEM;
+		goto error;
+	}
+
+	p = cmd_payload;
+	for (i = 0; i < nr_ids; i++) {
+		struct lttcomm_tracker_id_header *tracker_id;
+		struct lttng_tracker_id *id;
+		enum lttng_tracker_id_status status;
 
-	ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pids);
+		tracker_id = (struct lttcomm_tracker_id_header *) p;
+		p += sizeof(struct lttcomm_tracker_id_header);
+		id = lttng_tracker_ids_get_pointer_of_index(ids, i);
+		if (!id) {
+			ret = -LTTNG_ERR_INVALID;
+			goto error;
+		}
+
+		switch (tracker_id->type) {
+		case LTTNG_ID_ALL:
+			status = lttng_tracker_id_set_all(id);
+			break;
+		case LTTNG_ID_VALUE:
+			id->value = tracker_id->u.value;
+			status = lttng_tracker_id_set_value(
+					id, tracker_id->u.value);
+			break;
+		case LTTNG_ID_STRING:
+			status = lttng_tracker_id_set_string(id, p);
+			p += tracker_id->u.var_data_len;
+			break;
+		default:
+			goto error;
+		}
+
+		if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+			ret = -LTTNG_ERR_INVALID;
+			goto error;
+		}
+	}
+	free(cmd_payload);
+	*_ids = ids;
+	return 0;
+
+error:
+	lttng_tracker_ids_destroy(ids);
+	free(cmd_payload);
+	free(cmd_header);
+	return ret;
+}
+
+/*
+ * List PIDs in the tracker.
+ *
+ * enabled is set to whether the PID tracker is enabled.
+ * pids is set to an allocated array of PIDs currently tracked. On
+ * success, pids must be freed by the caller.
+ * nr_pids is set to the number of entries contained by the pids array.
+ *
+ * Returns 0 on success, else a negative LTTng error code.
+ */
+int lttng_list_tracker_pids(struct lttng_handle *handle,
+		int *_enabled, int32_t **_pids, size_t *_nr_pids)
+{
+	struct lttng_tracker_ids *ids = NULL;
+	unsigned int nr_ids = 0;
+	int *pids = NULL;
+	int ret = 0, i;
+	enum lttng_tracker_id_status status;
+	const struct lttng_tracker_id *id;
+
+	ret = lttng_list_tracker_ids(handle, LTTNG_TRACKER_PID, &ids);
 	if (ret < 0) {
 		return ret;
 	}
-	nr_pids = ret / sizeof(int32_t);
-	if (nr_pids > 0 && !pids) {
-		return -LTTNG_ERR_UNK;
+
+	status = lttng_tracker_ids_get_count(ids, &nr_ids);
+	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
 	}
-	if (nr_pids == 1 && pids[0] == -1) {
-		free(pids);
-		pids = NULL;
-		enabled = 0;
-		nr_pids = 0;
+
+	if (nr_ids == 1) {
+		id = lttng_tracker_ids_get_at_index(ids, 0);
+		if (id && lttng_tracker_id_get_type(id) == LTTNG_ID_ALL) {
+			*_enabled = 0;
+			goto end;
+		}
+	}
+
+	*_enabled = 1;
+
+	pids = zmalloc(nr_ids * sizeof(*pids));
+	if (!pids) {
+		ret = -LTTNG_ERR_NOMEM;
+		goto end;
+	}
+	for (i = 0; i < nr_ids; i++) {
+		id = lttng_tracker_ids_get_at_index(ids, i);
+		status = lttng_tracker_id_get_value(id, &pids[i]);
+		if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+			ret = -LTTNG_ERR_UNK;
+			goto end;
+		}
 	}
-	*_enabled = enabled;
 	*_pids = pids;
-	*_nr_pids = nr_pids;
-	return 0;
+	*_nr_pids = nr_ids;
+end:
+	lttng_tracker_ids_destroy(ids);
+	if (ret < 0) {
+		free(pids);
+	}
+	return ret;
 }
 
 /*
@@ -3055,6 +3127,131 @@ end:
 	return ret;
 }
 
+static int lttng_track_untrack_id(struct lttng_handle *handle,
+		enum lttng_tracker_type tracker_type,
+		const struct lttng_tracker_id *id,
+		enum lttcomm_sessiond_command cmd)
+{
+	int ret;
+	struct lttcomm_session_msg lsm;
+	const char *var_data;
+	size_t var_data_len = 0;
+	int value;
+	enum lttng_tracker_id_status status;
+
+	/* NULL arguments are forbidden. No default values. */
+	if (handle == NULL) {
+		goto error;
+	}
+
+	memset(&lsm, 0, sizeof(lsm));
+
+	lsm.cmd_type = cmd;
+	lsm.u.id_tracker.tracker_type = tracker_type;
+	lsm.u.id_tracker.id_type = lttng_tracker_id_get_type(id);
+	switch (lsm.u.id_tracker.id_type) {
+	case LTTNG_ID_ALL:
+		break;
+	case LTTNG_ID_VALUE:
+		status = lttng_tracker_id_get_value(id, &value);
+		if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+			goto error;
+		}
+		lsm.u.id_tracker.u.value = value;
+		break;
+	case LTTNG_ID_STRING:
+		status = lttng_tracker_id_get_string(id, &var_data);
+		if (status != LTTNG_TRACKER_ID_STATUS_OK) {
+			goto error;
+		}
+		var_data_len = strlen(var_data) + 1; /* Includes \0. */
+		lsm.u.id_tracker.u.var_len = var_data_len;
+		break;
+	default:
+		goto error;
+	}
+
+	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
+
+	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+			sizeof(lsm.session.name));
+
+	ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(
+			&lsm, (char *) var_data, var_data_len, NULL);
+	return ret;
+error:
+	return -LTTNG_ERR_INVALID;
+}
+
+/*
+ * Add ID to session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_track_id(struct lttng_handle *handle,
+		enum lttng_tracker_type tracker_type,
+		const struct lttng_tracker_id *id)
+{
+	return lttng_track_untrack_id(handle, tracker_type, id, LTTNG_TRACK_ID);
+}
+
+/*
+ * Remove ID from session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_untrack_id(struct lttng_handle *handle,
+		enum lttng_tracker_type tracker_type,
+		const struct lttng_tracker_id *id)
+{
+	return lttng_track_untrack_id(
+			handle, tracker_type, id, LTTNG_UNTRACK_ID);
+}
+
+/*
+ * Add PID to session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_track_pid(struct lttng_handle *handle, int pid)
+{
+	int ret;
+	struct lttng_tracker_id *id = NULL;
+	enum lttng_tracker_id_status status;
+
+	id = lttng_tracker_id_create();
+	status = lttng_tracker_id_set_value(id, pid);
+	if (status == LTTNG_TRACKER_ID_STATUS_INVALID) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
+
+	ret = lttng_track_id(handle, LTTNG_TRACKER_PID, id);
+error:
+	lttng_tracker_id_destroy(id);
+	return ret;
+}
+
+/*
+ * Remove PID from session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_untrack_pid(struct lttng_handle *handle, int pid)
+{
+	int ret;
+	struct lttng_tracker_id *id = NULL;
+	enum lttng_tracker_id_status status;
+
+	id = lttng_tracker_id_create();
+	status = lttng_tracker_id_set_value(id, pid);
+	if (status == LTTNG_TRACKER_ID_STATUS_INVALID) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
+
+	ret = lttng_untrack_id(handle, LTTNG_TRACKER_PID, id);
+error:
+	lttng_tracker_id_destroy(id);
+	return ret;
+}
+
 /*
  * lib constructor.
  */