X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=dc442035a3fe21e6b4c487a1007c9f05d1b38c56;hp=139133210406882cf8e3359287a892bb228c9c5b;hb=d7b377ed1acd4043bde353d99122e0e56fa4e975;hpb=aecf2da5ff4c92398b58af71ec10a3c2a311076e

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index 139133210..dc442035a 100644
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -23,6 +23,8 @@
 #include <common/kernel-ctl/kernel-ctl.h>
 #include <common/dynamic-buffer.h>
 #include <common/buffer-view.h>
+#include <common/payload.h>
+#include <common/payload-view.h>
 #include <common/trace-chunk.h>
 #include <lttng/location-internal.h>
 #include <lttng/trigger/trigger-internal.h>
@@ -35,6 +37,8 @@
 #include <lttng/session-internal.h>
 #include <lttng/userspace-probe-internal.h>
 #include <lttng/session-descriptor-internal.h>
+#include <lttng/lttng-error.h>
+#include <lttng/tracker.h>
 #include <common/string-utils/string-utils.h>
 
 #include "channel.h"
@@ -54,6 +58,7 @@
 #include "rotation-thread.h"
 #include "timer.h"
 #include "agent-thread.h"
+#include "tracker.h"
 
 #include "cmd.h"
 
@@ -390,95 +395,69 @@ end:
 	}
 }
 
-static int increment_extended_len(const char *filter_expression,
-		struct lttng_event_exclusion *exclusion,
-		const struct lttng_userspace_probe_location *probe_location,
-		size_t *extended_len)
-{
-	int ret = 0;
-
-	*extended_len += sizeof(struct lttcomm_event_extended_header);
-
-	if (filter_expression) {
-		*extended_len += strlen(filter_expression) + 1;
-	}
-
-	if (exclusion) {
-		*extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN;
-	}
-
-	if (probe_location) {
-		ret = lttng_userspace_probe_location_serialize(probe_location,
-				NULL, NULL);
-		if (ret < 0) {
-			goto end;
-		}
-		*extended_len += ret;
-	}
-	ret = 0;
-end:
-	return ret;
-}
-
 static int append_extended_info(const char *filter_expression,
 		struct lttng_event_exclusion *exclusion,
 		struct lttng_userspace_probe_location *probe_location,
-		void **extended_at)
+		struct lttng_payload *payload)
 {
 	int ret = 0;
 	size_t filter_len = 0;
 	size_t nb_exclusions = 0;
 	size_t userspace_probe_location_len = 0;
-	struct lttng_dynamic_buffer location_buffer;
-	struct lttcomm_event_extended_header extended_header;
+	struct lttcomm_event_extended_header extended_header = {};
+	struct lttcomm_event_extended_header *p_extended_header;
+	const size_t original_payload_size = payload->buffer.size;
+
+	ret = lttng_dynamic_buffer_append(&payload->buffer, &extended_header,
+			sizeof(extended_header));
+	if (ret) {
+		goto end;
+	}
 
 	if (filter_expression) {
 		filter_len = strlen(filter_expression) + 1;
+		ret = lttng_dynamic_buffer_append(&payload->buffer,
+				filter_expression, filter_len);
+		if (ret) {
+			goto end;
+		}
 	}
 
 	if (exclusion) {
+		const size_t len = exclusion->count * LTTNG_SYMBOL_NAME_LEN;
+
 		nb_exclusions = exclusion->count;
+
+		ret = lttng_dynamic_buffer_append(
+				&payload->buffer, &exclusion->names, len);
+		if (ret) {
+			goto end;
+		}
 	}
 
 	if (probe_location) {
-		lttng_dynamic_buffer_init(&location_buffer);
+		const size_t size_before_probe = payload->buffer.size;
+
 		ret = lttng_userspace_probe_location_serialize(probe_location,
-				&location_buffer, NULL);
+				payload);
 		if (ret < 0) {
 			ret = -1;
 			goto end;
 		}
-		userspace_probe_location_len = location_buffer.size;
-	}
 
-	/* Set header fields */
-	extended_header.filter_len = filter_len;
-	extended_header.nb_exclusions = nb_exclusions;
-	extended_header.userspace_probe_location_len = userspace_probe_location_len;
-
-	/* Copy header */
-	memcpy(*extended_at, &extended_header, sizeof(extended_header));
-	*extended_at += sizeof(extended_header);
-
-	/* Copy filter string */
-	if (filter_expression) {
-		memcpy(*extended_at, filter_expression, filter_len);
-		*extended_at += filter_len;
+		userspace_probe_location_len =
+				payload->buffer.size - size_before_probe;
 	}
 
-	/* Copy exclusion names */
-	if (exclusion) {
-		size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN;
+	/* Set header fields */
+	p_extended_header = (struct lttcomm_event_extended_header *)
+			(payload->buffer.data + original_payload_size);
 
-		memcpy(*extended_at, &exclusion->names, len);
-		*extended_at += len;
-	}
+	p_extended_header->filter_len = filter_len;
+	p_extended_header->nb_exclusions = nb_exclusions;
+	p_extended_header->userspace_probe_location_len =
+			userspace_probe_location_len;
 
-	if (probe_location) {
-		memcpy(*extended_at, location_buffer.data, location_buffer.size);
-		*extended_at += location_buffer.size;
-		lttng_dynamic_buffer_reset(&location_buffer);
-	}
 	ret = 0;
 end:
 	return ret;
@@ -490,89 +469,55 @@ end:
  * Return number of events in list on success or else a negative value.
  */
 static int list_lttng_agent_events(struct agent *agt,
-		struct lttng_event **events, size_t *total_size)
+		struct lttng_payload *payload)
 {
-	int i = 0, ret = 0;
-	unsigned int nb_event = 0;
-	struct agent_event *event;
-	struct lttng_event *tmp_events = NULL;
+	int nb_events = 0, ret = 0;
+	const struct agent_event *agent_event;
 	struct lttng_ht_iter iter;
-	size_t extended_len = 0;
-	void *extended_at;
 
 	assert(agt);
-	assert(events);
 
 	DBG3("Listing agent events");
 
 	rcu_read_lock();
-	nb_event = lttng_ht_get_count(agt->events);
-	rcu_read_unlock();
-	if (nb_event == 0) {
-		ret = nb_event;
-		*total_size = 0;
-		goto error;
-	}
-
-	/* Compute required extended infos size */
-	extended_len = nb_event * sizeof(struct lttcomm_event_extended_header);
-
-	/*
-	 * This is only valid because the commands which add events are
-	 * processed in the same thread as the listing.
-	 */
-	rcu_read_lock();
-	cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
-		ret = increment_extended_len(event->filter_expression, NULL, NULL,
-				&extended_len);
+	cds_lfht_for_each_entry (
+			agt->events->ht, &iter.iter, agent_event, node.node) {
+		struct lttng_event event = {
+			.enabled = agent_event->enabled,
+			.loglevel = agent_event->loglevel_value,
+			.loglevel_type = agent_event->loglevel_type,
+		};
+
+		strncpy(event.name, agent_event->name, sizeof(event.name));
+		event.name[sizeof(event.name) - 1] = '\0';
+
+		ret = lttng_dynamic_buffer_append(
+				&payload->buffer, &event, sizeof(event));
 		if (ret) {
-			DBG("Error computing the length of extended info message");
-			ret = -LTTNG_ERR_FATAL;
-			goto error;
+			ERR("Failed to append event to payload");
+			ret = -LTTNG_ERR_NOMEM;
+			goto end;
 		}
-	}
-	rcu_read_unlock();
 
-	*total_size = nb_event * sizeof(*tmp_events) + extended_len;
-	tmp_events = zmalloc(*total_size);
-	if (!tmp_events) {
-		PERROR("zmalloc agent events session");
-		ret = -LTTNG_ERR_FATAL;
-		goto error;
+		nb_events++;
 	}
 
-	extended_at = ((uint8_t *) tmp_events) +
-		nb_event * sizeof(struct lttng_event);
-
-	rcu_read_lock();
-	cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
-		strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name));
-		tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0';
-		tmp_events[i].enabled = event->enabled;
-		tmp_events[i].loglevel = event->loglevel_value;
-		tmp_events[i].loglevel_type = event->loglevel_type;
-		i++;
-
-		/* Append extended info */
-		ret = append_extended_info(event->filter_expression, NULL, NULL,
-				&extended_at);
+	cds_lfht_for_each_entry (
+		agt->events->ht, &iter.iter, agent_event, node.node) {
+		/* Append extended info. */
+		ret = append_extended_info(agent_event->filter_expression, NULL,
+				NULL, payload);
 		if (ret) {
-			DBG("Error appending extended info message");
-			ret = -LTTNG_ERR_FATAL;
-			goto error;
+			ERR("Failed to append extended event info to payload");
+			ret = -LTTNG_ERR_NOMEM;
+			goto end;
 		}
 	}
 
-	*events = tmp_events;
-	ret = nb_event;
-	assert(nb_event == i);
-
+	ret = nb_events;
 end:
 	rcu_read_unlock();
 	return ret;
-error:
-	free(tmp_events);
-	goto end;
 }
 
 /*
@@ -580,23 +525,20 @@ error:
  */
 static int list_lttng_ust_global_events(char *channel_name,
 		struct ltt_ust_domain_global *ust_global,
-		struct lttng_event **events, size_t *total_size)
+		struct lttng_payload *payload)
 {
-	int i = 0, ret = 0;
-	unsigned int nb_event = 0;
+	int ret = 0;
+	unsigned int nb_events = 0;
 	struct lttng_ht_iter iter;
-	struct lttng_ht_node_str *node;
-	struct ltt_ust_channel *uchan;
-	struct ltt_ust_event *uevent;
-	struct lttng_event *tmp;
-	size_t extended_len = 0;
-	void *extended_at;
+	const struct lttng_ht_node_str *node;
+	const struct ltt_ust_channel *uchan;
+	const struct ltt_ust_event *uevent;
 
 	DBG("Listing UST global events for channel %s", channel_name);
 
 	rcu_read_lock();
 
-	lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter);
+	lttng_ht_lookup(ust_global->channels, (void *) channel_name, &iter);
 	node = lttng_ht_iter_get_node_str(&iter);
 	if (node == NULL) {
 		ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
@@ -605,99 +547,75 @@ static int list_lttng_ust_global_events(char *channel_name,
 
 	uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
 
-	nb_event = lttng_ht_get_count(uchan->events);
-	if (nb_event == 0) {
-		ret = nb_event;
-		*total_size = 0;
-		goto end;
-	}
-
-	DBG3("Listing UST global %d events", nb_event);
+	DBG3("Listing UST global events");
 
-	/* Compute required extended infos size */
 	cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
+		struct lttng_event event = {};
+
 		if (uevent->internal) {
-			nb_event--;
 			continue;
 		}
 
-		ret = increment_extended_len(uevent->filter_expression,
-			uevent->exclusion, NULL, &extended_len);
-		if (ret) {
-			DBG("Error computing the length of extended info message");
-			ret = -LTTNG_ERR_FATAL;
-			goto end;
-		}
-	}
-	if (nb_event == 0) {
-		/* All events are internal, skip. */
-		ret = 0;
-		*total_size = 0;
-		goto end;
-	}
+		strncpy(event.name, uevent->attr.name, sizeof(event.name));
+		event.name[sizeof(event.name) - 1] = '\0';
 
-	*total_size = nb_event * sizeof(struct lttng_event) + extended_len;
-	tmp = zmalloc(*total_size);
-	if (tmp == NULL) {
-		ret = -LTTNG_ERR_FATAL;
-		goto end;
-	}
-
-	extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event);
-
-	cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
-		if (uevent->internal) {
-			/* This event should remain hidden from clients */
-			continue;
-		}
-		strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
-		tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
-		tmp[i].enabled = uevent->enabled;
+		event.enabled = uevent->enabled;
 
 		switch (uevent->attr.instrumentation) {
 		case LTTNG_UST_TRACEPOINT:
-			tmp[i].type = LTTNG_EVENT_TRACEPOINT;
+			event.type = LTTNG_EVENT_TRACEPOINT;
 			break;
 		case LTTNG_UST_PROBE:
-			tmp[i].type = LTTNG_EVENT_PROBE;
+			event.type = LTTNG_EVENT_PROBE;
 			break;
 		case LTTNG_UST_FUNCTION:
-			tmp[i].type = LTTNG_EVENT_FUNCTION;
+			event.type = LTTNG_EVENT_FUNCTION;
 			break;
 		}
 
-		tmp[i].loglevel = uevent->attr.loglevel;
+		event.loglevel = uevent->attr.loglevel;
 		switch (uevent->attr.loglevel_type) {
 		case LTTNG_UST_LOGLEVEL_ALL:
-			tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
+			event.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
 			break;
 		case LTTNG_UST_LOGLEVEL_RANGE:
-			tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
+			event.loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
 			break;
 		case LTTNG_UST_LOGLEVEL_SINGLE:
-			tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
+			event.loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
 			break;
 		}
+
 		if (uevent->filter) {
-			tmp[i].filter = 1;
+			event.filter = 1;
 		}
+
 		if (uevent->exclusion) {
-			tmp[i].exclusion = 1;
+			event.exclusion = 1;
+		}
+
+		ret = lttng_dynamic_buffer_append(&payload->buffer, &event, sizeof(event));
+		if (ret) {
+			ERR("Failed to append event to payload");
+			ret = -LTTNG_ERR_NOMEM;
+			goto end;
 		}
-		i++;
 
-		/* Append extended info */
+		nb_events++;
+	}
+
+	cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
+		/* Append extended info. */
 		ret = append_extended_info(uevent->filter_expression,
-			uevent->exclusion, NULL, &extended_at);
+				uevent->exclusion, NULL, payload);
 		if (ret) {
-			DBG("Error appending extended info message");
+			ERR("Failed to append extended event info to payload");
 			ret = -LTTNG_ERR_FATAL;
 			goto end;
 		}
 	}
 
-	ret = nb_event;
-	*events = tmp;
+	ret = nb_events;
 end:
 	rcu_read_unlock();
 	return ret;
@@ -708,14 +626,12 @@ end:
  */
 static int list_lttng_kernel_events(char *channel_name,
 		struct ltt_kernel_session *kernel_session,
-		struct lttng_event **events, size_t *total_size)
+		struct lttng_payload *payload)
 {
-	int i = 0, ret;
+	int ret;
 	unsigned int nb_event;
-	struct ltt_kernel_event *event;
-	struct ltt_kernel_channel *kchan;
-	size_t extended_len = 0;
-	void *extended_at;
+	const struct ltt_kernel_event *kevent;
+	const struct ltt_kernel_channel *kchan;
 
 	kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
 	if (kchan == NULL) {
@@ -727,69 +643,42 @@ static int list_lttng_kernel_events(char *channel_name,
 
 	DBG("Listing events for channel %s", kchan->channel->name);
 
-	if (nb_event == 0) {
-		*total_size = 0;
-		*events = NULL;
-		goto end;
-	}
-
-	/* Compute required extended infos size */
-	cds_list_for_each_entry(event, &kchan->events_list.head, list) {
-		ret = increment_extended_len(event->filter_expression, NULL,
-			event->userspace_probe_location,
-			&extended_len);
-		if (ret) {
-			DBG("Error computing the length of extended info message");
-			ret = -LTTNG_ERR_FATAL;
-			goto error;
-		}
-	}
-
-	*total_size = nb_event * sizeof(struct lttng_event) + extended_len;
-	*events = zmalloc(*total_size);
-	if (*events == NULL) {
-		ret = -LTTNG_ERR_FATAL;
-		goto error;
-	}
+	/* Kernel channels */
+	cds_list_for_each_entry(kevent, &kchan->events_list.head , list) {
+		struct lttng_event event = {};
 
-	extended_at = ((void *) *events) +
-		nb_event * sizeof(struct lttng_event);
+		strncpy(event.name, kevent->event->name, sizeof(event.name));
+		event.name[sizeof(event.name) - 1] = '\0';
+		event.enabled = kevent->enabled;
+		event.filter = (unsigned char) !!kevent->filter_expression;
 
-	/* Kernel channels */
-	cds_list_for_each_entry(event, &kchan->events_list.head , list) {
-		strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
-		(*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
-		(*events)[i].enabled = event->enabled;
-		(*events)[i].filter =
-				(unsigned char) !!event->filter_expression;
-
-		switch (event->event->instrumentation) {
+		switch (kevent->event->instrumentation) {
 		case LTTNG_KERNEL_TRACEPOINT:
-			(*events)[i].type = LTTNG_EVENT_TRACEPOINT;
+			event.type = LTTNG_EVENT_TRACEPOINT;
 			break;
 		case LTTNG_KERNEL_KRETPROBE:
-			(*events)[i].type = LTTNG_EVENT_FUNCTION;
-			memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
+			event.type = LTTNG_EVENT_FUNCTION;
+			memcpy(&event.attr.probe, &kevent->event->u.kprobe,
 					sizeof(struct lttng_kernel_kprobe));
 			break;
 		case LTTNG_KERNEL_KPROBE:
-			(*events)[i].type = LTTNG_EVENT_PROBE;
-			memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
+			event.type = LTTNG_EVENT_PROBE;
+			memcpy(&event.attr.probe, &kevent->event->u.kprobe,
 					sizeof(struct lttng_kernel_kprobe));
 			break;
 		case LTTNG_KERNEL_UPROBE:
-			(*events)[i].type = LTTNG_EVENT_USERSPACE_PROBE;
+			event.type = LTTNG_EVENT_USERSPACE_PROBE;
 			break;
 		case LTTNG_KERNEL_FUNCTION:
-			(*events)[i].type = LTTNG_EVENT_FUNCTION;
-			memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace,
+			event.type = LTTNG_EVENT_FUNCTION;
+			memcpy(&event.attr.ftrace, &kevent->event->u.ftrace,
 					sizeof(struct lttng_kernel_function));
 			break;
 		case LTTNG_KERNEL_NOOP:
-			(*events)[i].type = LTTNG_EVENT_NOOP;
+			event.type = LTTNG_EVENT_NOOP;
 			break;
 		case LTTNG_KERNEL_SYSCALL:
-			(*events)[i].type = LTTNG_EVENT_SYSCALL;
+			event.type = LTTNG_EVENT_SYSCALL;
 			break;
 		case LTTNG_KERNEL_ALL:
 			/* fall-through. */
@@ -797,11 +686,20 @@ static int list_lttng_kernel_events(char *channel_name,
 			assert(0);
 			break;
 		}
-		i++;
 
-		/* Append extended info */
-		ret = append_extended_info(event->filter_expression, NULL,
-			event->userspace_probe_location, &extended_at);
+		ret = lttng_dynamic_buffer_append(
+				&payload->buffer, &event, sizeof(event));
+		if (ret) {
+			ERR("Failed to append event to payload");
+			ret = -LTTNG_ERR_NOMEM;
+			goto end;
+		}
+	}
+
+	cds_list_for_each_entry(kevent, &kchan->events_list.head , list) {
+		/* Append extended info. */
+		ret = append_extended_info(kevent->filter_expression, NULL,
+				kevent->userspace_probe_location, payload);
 		if (ret) {
 			DBG("Error appending extended info message");
 			ret = -LTTNG_ERR_FATAL;
@@ -811,10 +709,8 @@ static int list_lttng_kernel_events(char *channel_name,
 
 end:
 	return nb_event;
-
 error:
-	/* Negate the error code to differentiate the size from an error */
-	return -ret;
+	return ret;
 }
 
 /*
@@ -1050,7 +946,7 @@ static enum lttng_error_code send_consumer_relayd_socket(
 		struct consumer_socket *consumer_sock,
 		const char *session_name, const char *hostname,
 		const char *base_path, int session_live_timer,
-	        const uint64_t *current_chunk_id,
+		const uint64_t *current_chunk_id,
 		time_t session_creation_time,
 		bool session_name_contains_creation_time)
 {
@@ -1178,9 +1074,9 @@ int cmd_setup_relayd(struct ltt_session *session)
 	struct ltt_kernel_session *ksess;
 	struct consumer_socket *socket;
 	struct lttng_ht_iter iter;
-        LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
+	LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
 
-        assert(session);
+	assert(session);
 
 	usess = session->ust_session;
 	ksess = session->kernel_session;
@@ -1431,112 +1327,6 @@ error:
 	return ret;
 }
 
-/*
- * Command LTTNG_TRACK_ID processed by the client thread.
- *
- * Called with session lock held.
- */
-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;
-
-	rcu_read_lock();
-
-	switch (domain) {
-	case LTTNG_DOMAIN_KERNEL:
-	{
-		struct ltt_kernel_session *ksess;
-
-		ksess = session->kernel_session;
-
-		ret = kernel_track_id(tracker_type, ksess, id);
-		if (ret != LTTNG_OK) {
-			goto error;
-		}
-
-		kernel_wait_quiescent();
-		break;
-	}
-	case LTTNG_DOMAIN_UST:
-	{
-		struct ltt_ust_session *usess;
-
-		usess = session->ust_session;
-
-		ret = trace_ust_track_id(tracker_type, usess, id);
-		if (ret != LTTNG_OK) {
-			goto error;
-		}
-		break;
-	}
-	default:
-		ret = LTTNG_ERR_UNKNOWN_DOMAIN;
-		goto error;
-	}
-
-	ret = LTTNG_OK;
-
-error:
-	rcu_read_unlock();
-	return ret;
-}
-
-/*
- * Command LTTNG_UNTRACK_ID processed by the client thread.
- *
- * Called with session lock held.
- */
-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;
-
-	rcu_read_lock();
-
-	switch (domain) {
-	case LTTNG_DOMAIN_KERNEL:
-	{
-		struct ltt_kernel_session *ksess;
-
-		ksess = session->kernel_session;
-
-		ret = kernel_untrack_id(tracker_type, ksess, id);
-		if (ret != LTTNG_OK) {
-			goto error;
-		}
-
-		kernel_wait_quiescent();
-		break;
-	}
-	case LTTNG_DOMAIN_UST:
-	{
-		struct ltt_ust_session *usess;
-
-		usess = session->ust_session;
-
-		ret = trace_ust_untrack_id(tracker_type, usess, id);
-		if (ret != LTTNG_OK) {
-			goto error;
-		}
-		break;
-	}
-	default:
-		ret = LTTNG_ERR_UNKNOWN_DOMAIN;
-		goto error;
-	}
-
-	ret = LTTNG_OK;
-
-error:
-	rcu_read_unlock();
-	return ret;
-}
-
 /*
  * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
  *
@@ -1708,6 +1498,211 @@ end:
 	return ret;
 }
 
+enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy(
+		struct ltt_session *session,
+		enum lttng_domain_type domain,
+		enum lttng_process_attr process_attr,
+		enum lttng_tracking_policy *policy)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+	const struct process_attr_tracker *tracker;
+
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (!session->kernel_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		tracker = kernel_get_process_attr_tracker(
+				session->kernel_session, process_attr);
+		break;
+	case LTTNG_DOMAIN_UST:
+		if (!session->ust_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		tracker = trace_ust_get_process_attr_tracker(
+				session->ust_session, process_attr);
+		break;
+	default:
+		ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+		goto end;
+	}
+	if (tracker) {
+		*policy = process_attr_tracker_get_tracking_policy(tracker);
+	} else {
+		ret_code = LTTNG_ERR_INVALID;
+	}
+end:
+	return ret_code;
+}
+
+enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy(
+		struct ltt_session *session,
+		enum lttng_domain_type domain,
+		enum lttng_process_attr process_attr,
+		enum lttng_tracking_policy policy)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+
+	switch (policy) {
+	case LTTNG_TRACKING_POLICY_INCLUDE_SET:
+	case LTTNG_TRACKING_POLICY_EXCLUDE_ALL:
+	case LTTNG_TRACKING_POLICY_INCLUDE_ALL:
+		break;
+	default:
+		ret_code = LTTNG_ERR_INVALID;
+		goto end;
+	}
+
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (!session->kernel_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		ret_code = kernel_process_attr_tracker_set_tracking_policy(
+				session->kernel_session, process_attr, policy);
+		break;
+	case LTTNG_DOMAIN_UST:
+		if (!session->ust_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		ret_code = trace_ust_process_attr_tracker_set_tracking_policy(
+				session->ust_session, process_attr, policy);
+		break;
+	default:
+		ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+		break;
+	}
+end:
+	return ret_code;
+}
+
+enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value(
+		struct ltt_session *session,
+		enum lttng_domain_type domain,
+		enum lttng_process_attr process_attr,
+		const struct process_attr_value *value)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (!session->kernel_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		ret_code = kernel_process_attr_tracker_inclusion_set_add_value(
+				session->kernel_session, process_attr, value);
+		break;
+	case LTTNG_DOMAIN_UST:
+		if (!session->ust_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value(
+				session->ust_session, process_attr, value);
+		break;
+	default:
+		ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+		break;
+	}
+end:
+	return ret_code;
+}
+
+enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value(
+		struct ltt_session *session,
+		enum lttng_domain_type domain,
+		enum lttng_process_attr process_attr,
+		const struct process_attr_value *value)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (!session->kernel_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		ret_code = kernel_process_attr_tracker_inclusion_set_remove_value(
+				session->kernel_session, process_attr, value);
+		break;
+	case LTTNG_DOMAIN_UST:
+		if (!session->ust_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value(
+				session->ust_session, process_attr, value);
+		break;
+	default:
+		ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+		break;
+	}
+end:
+	return ret_code;
+}
+
+enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set(
+		struct ltt_session *session,
+		enum lttng_domain_type domain,
+		enum lttng_process_attr process_attr,
+		struct lttng_process_attr_values **values)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+	const struct process_attr_tracker *tracker;
+	enum process_attr_tracker_status status;
+
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (!session->kernel_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		tracker = kernel_get_process_attr_tracker(
+				session->kernel_session, process_attr);
+		break;
+	case LTTNG_DOMAIN_UST:
+		if (!session->ust_session) {
+			ret_code = LTTNG_ERR_INVALID;
+			goto end;
+		}
+		tracker = trace_ust_get_process_attr_tracker(
+				session->ust_session, process_attr);
+		break;
+	default:
+		ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+		goto end;
+	}
+
+	if (!tracker) {
+		ret_code = LTTNG_ERR_INVALID;
+		goto end;
+	}
+
+	status = process_attr_tracker_get_inclusion_set(tracker, values);
+	switch (status) {
+	case PROCESS_ATTR_TRACKER_STATUS_OK:
+		ret_code = LTTNG_OK;
+		break;
+	case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
+		ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
+		break;
+	case PROCESS_ATTR_TRACKER_STATUS_ERROR:
+		ret_code = LTTNG_ERR_NOMEM;
+		break;
+	default:
+		ret_code = LTTNG_ERR_UNK;
+		break;
+	}
+
+end:
+	return ret_code;
+}
+
 /*
  * Command LTTNG_DISABLE_EVENT processed by the client thread.
  */
@@ -2293,7 +2288,7 @@ static int _cmd_enable_event(struct ltt_session *session,
 			 */
 			ret = validate_ust_event_name(event->name);
 			if (ret) {
-			        WARN("Userspace event name %s failed validation.",
+				WARN("Userspace event name %s failed validation.",
 						event->name);
 				ret = LTTNG_ERR_INVALID_EVENT_NAME;
 				goto error;
@@ -2566,56 +2561,6 @@ ssize_t cmd_list_syscalls(struct lttng_event **events)
 	return syscall_table_list(events);
 }
 
-/*
- * Command LTTNG_LIST_TRACKER_IDS processed by the client thread.
- *
- * Called with session lock held.
- */
-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 = LTTNG_OK;
-
-	switch (domain) {
-	case LTTNG_DOMAIN_KERNEL:
-	{
-		struct ltt_kernel_session *ksess;
-
-		ksess = session->kernel_session;
-		ret = kernel_list_tracker_ids(tracker_type, ksess, ids);
-		if (ret != LTTNG_OK) {
-			ret = -LTTNG_ERR_KERN_LIST_FAIL;
-			goto error;
-		}
-		break;
-	}
-	case LTTNG_DOMAIN_UST:
-	{
-		struct ltt_ust_session *usess;
-
-		usess = session->ust_session;
-		ret = trace_ust_list_tracker_ids(tracker_type, usess, ids);
-		if (ret != LTTNG_OK) {
-			ret = -LTTNG_ERR_UST_LIST_FAIL;
-			goto error;
-		}
-		break;
-	}
-	case LTTNG_DOMAIN_LOG4J:
-	case LTTNG_DOMAIN_JUL:
-	case LTTNG_DOMAIN_PYTHON:
-	default:
-		ret = -LTTNG_ERR_UND;
-		goto error;
-	}
-
-error:
-	/* Return negative value to differentiate return code */
-	return ret;
-}
-
 /*
  * Command LTTNG_START_TRACE processed by the client thread.
  *
@@ -2739,6 +2684,16 @@ int cmd_start_trace(struct ltt_session *session)
 		}
 	}
 
+	/*
+	 * Open a packet in every stream of the session to ensure that viewers
+	 * can correctly identify the boundaries of the periods during which
+	 * tracing was active for this session.
+	 */
+	ret = session_open_packets(session);
+	if (ret != LTTNG_OK) {
+		goto error;
+	}
+
 	/*
 	 * Clear the flag that indicates that a rotation was done while the
 	 * session was stopped.
@@ -3122,19 +3077,19 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
 	enum lttng_error_code ret_code;
 
 	lttng_dynamic_buffer_init(&payload);
-	if (cmd_ctx->lsm->u.create_session.home_dir_size >=
+	if (cmd_ctx->lsm.u.create_session.home_dir_size >=
 			LTTNG_PATH_MAX) {
 		ret_code = LTTNG_ERR_INVALID;
 		goto error;
 	}
-	if (cmd_ctx->lsm->u.create_session.session_descriptor_size >
+	if (cmd_ctx->lsm.u.create_session.session_descriptor_size >
 			LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
 		ret_code = LTTNG_ERR_INVALID;
 		goto error;
 	}
 
-	payload_size = cmd_ctx->lsm->u.create_session.home_dir_size +
-			cmd_ctx->lsm->u.create_session.session_descriptor_size;
+	payload_size = cmd_ctx->lsm.u.create_session.home_dir_size +
+			cmd_ctx->lsm.u.create_session.session_descriptor_size;
 	ret = lttng_dynamic_buffer_set_size(&payload, payload_size);
 	if (ret) {
 		ret_code = LTTNG_ERR_NOMEM;
@@ -3151,11 +3106,11 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
 	home_dir_view = lttng_buffer_view_from_dynamic_buffer(
 			&payload,
 			0,
-			cmd_ctx->lsm->u.create_session.home_dir_size);
+			cmd_ctx->lsm.u.create_session.home_dir_size);
 	session_descriptor_view = lttng_buffer_view_from_dynamic_buffer(
 			&payload,
-			cmd_ctx->lsm->u.create_session.home_dir_size,
-			cmd_ctx->lsm->u.create_session.session_descriptor_size);
+			cmd_ctx->lsm.u.create_session.home_dir_size,
+			cmd_ctx->lsm.u.create_session.session_descriptor_size);
 
 	ret = lttng_session_descriptor_create_from_buffer(
 			&session_descriptor_view, &session_descriptor);
@@ -3209,10 +3164,10 @@ void cmd_destroy_session_reply(const struct ltt_session *session,
 	lttng_dynamic_buffer_init(&payload);
 
 	ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm));
-        if (ret) {
+	if (ret) {
 		ERR("Failed to append session destruction message");
 		goto error;
-        }
+	}
 
 	cmd_header.rotation_state =
 			(int32_t) (reply_context->implicit_rotation_on_destroy ?
@@ -3335,10 +3290,10 @@ int cmd_destroy_session(struct ltt_session *session,
 					session->name, lttng_strerror(-ret));
 			destruction_last_error = -ret;
 		}
-                if (reply_context) {
+		if (reply_context) {
 			reply_context->implicit_rotation_on_destroy = true;
-                }
-        } else if (session->has_been_started && session->current_trace_chunk) {
+		}
+	} else if (session->has_been_started && session->current_trace_chunk) {
 		/*
 		 * The user has not triggered a session rotation. However, to
 		 * ensure all data has been consumed, the session is rotated
@@ -3350,9 +3305,17 @@ int cmd_destroy_session(struct ltt_session *session,
 		 */
 		ret = cmd_rotate_session(session, NULL, true,
 			LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
-		if (ret != LTTNG_OK) {
+		/*
+		 * Rotation operations may not be supported by the kernel
+		 * tracer. Hence, do not consider this implicit rotation as
+		 * a session destruction error. The library has already stopped
+		 * the session and waited for pending data; there is nothing
+		 * left to do but complete the destruction of the session.
+		 */
+		if (ret != LTTNG_OK &&
+				ret != -LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL) {
 			ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
-					session->name, lttng_strerror(-ret));
+			    session->name, lttng_strerror(ret));
 			destruction_last_error = -ret;
 		}
 	}
@@ -3428,8 +3391,8 @@ int cmd_destroy_session(struct ltt_session *session,
 		} else {
 			*sock_fd = -1;
 		}
-        }
-        ret = LTTNG_OK;
+	}
+	ret = LTTNG_OK;
 end:
 	return ret;
 }
@@ -3658,25 +3621,33 @@ end:
  */
 ssize_t cmd_list_events(enum lttng_domain_type domain,
 		struct ltt_session *session, char *channel_name,
-		struct lttng_event **events, size_t *total_size)
+		struct lttng_payload *payload)
 {
 	int ret = 0;
-	ssize_t nb_event = 0;
+	ssize_t nb_events = 0;
+	struct lttcomm_event_command_header cmd_header = {};
+	const size_t cmd_header_offset = payload->buffer.size;
+
+	ret = lttng_dynamic_buffer_append(
+			&payload->buffer, &cmd_header, sizeof(cmd_header));
+	if (ret) {
+		ret = LTTNG_ERR_NOMEM;
+		goto error;
+	}
 
 	switch (domain) {
 	case LTTNG_DOMAIN_KERNEL:
 		if (session->kernel_session != NULL) {
-			nb_event = list_lttng_kernel_events(channel_name,
-					session->kernel_session, events,
-					total_size);
+			nb_events = list_lttng_kernel_events(channel_name,
+					session->kernel_session, payload);
 		}
 		break;
 	case LTTNG_DOMAIN_UST:
 	{
 		if (session->ust_session != NULL) {
-			nb_event = list_lttng_ust_global_events(channel_name,
-					&session->ust_session->domain_global, events,
-					total_size);
+			nb_events = list_lttng_ust_global_events(channel_name,
+					&session->ust_session->domain_global,
+					payload);
 		}
 		break;
 	}
@@ -3691,9 +3662,8 @@ ssize_t cmd_list_events(enum lttng_domain_type domain,
 			cds_lfht_for_each_entry(session->ust_session->agents->ht,
 					&iter.iter, agt, node.node) {
 				if (agt->domain == domain) {
-					nb_event = list_lttng_agent_events(
-							agt, events,
-							total_size);
+					nb_events = list_lttng_agent_events(
+							agt, payload);
 					break;
 				}
 			}
@@ -3705,7 +3675,10 @@ ssize_t cmd_list_events(enum lttng_domain_type domain,
 		goto error;
 	}
 
-	return nb_event;
+	((struct lttcomm_event_command_header *) (payload->buffer.data +
+			 cmd_header_offset))->nb_events = (uint32_t) nb_events;
+
+	return nb_events;
 
 error:
 	/* Return negative value to differentiate return code */
@@ -3726,7 +3699,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions,
 	unsigned int i = 0;
 	struct ltt_session *session;
 	struct ltt_session_list *list = session_get_list();
-        struct lttng_session_extended *extended =
+	struct lttng_session_extended *extended =
 			(typeof(extended)) (&sessions[session_count]);
 
 	DBG("Getting all available session for UID %d GID %d",
@@ -3742,7 +3715,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions,
 		/*
 		 * Only list the sessions the user can control.
 		 */
-		if (!session_access_ok(session, uid, gid) ||
+		if (!session_access_ok(session, uid) ||
 				session->destroyed) {
 			session_put(session);
 			continue;
@@ -4290,19 +4263,23 @@ int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock,
 	size_t trigger_len;
 	ssize_t sock_recv_len;
 	struct lttng_trigger *trigger = NULL;
-	struct lttng_buffer_view view;
-	struct lttng_dynamic_buffer trigger_buffer;
+	struct lttng_payload trigger_payload;
+	struct lttng_credentials cmd_creds = {
+		.uid = cmd_ctx->creds.uid,
+		.gid = cmd_ctx->creds.gid,
+	};
 
-	lttng_dynamic_buffer_init(&trigger_buffer);
-	trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
-	ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
+	lttng_payload_init(&trigger_payload);
+	trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length;
+	ret = lttng_dynamic_buffer_set_size(
+			&trigger_payload.buffer, trigger_len);
 	if (ret) {
 		ret = LTTNG_ERR_NOMEM;
 		goto end;
 	}
 
-	sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
-			trigger_len);
+	sock_recv_len = lttcomm_recv_unix_sock(
+			sock, trigger_payload.buffer.data, trigger_len);
 	if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
 		ERR("Failed to receive \"register trigger\" command payload");
 		/* TODO: should this be a new error enum ? */
@@ -4310,21 +4287,44 @@ int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock,
 		goto end;
 	}
 
-	view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
-	if (lttng_trigger_create_from_buffer(&view, &trigger) !=
-			trigger_len) {
-		ERR("Invalid trigger payload received in \"register trigger\" command");
-		ret = LTTNG_ERR_INVALID_TRIGGER;
-		goto end;
+	/* Receive fds, if any. */
+	if (cmd_ctx->lsm.fd_count > 0) {
+		ret = lttcomm_recv_payload_fds_unix_sock(
+				sock, cmd_ctx->lsm.fd_count, &trigger_payload);
+		if (ret > 0 && ret != cmd_ctx->lsm.fd_count * sizeof(int)) {
+			ret = LTTNG_ERR_INVALID_PROTOCOL;
+			goto end;
+		} else if (ret <= 0) {
+			ret = LTTNG_ERR_FATAL;
+			goto end;
+		}
+	}
+
+	/* Deserialize trigger. */
+	{
+		struct lttng_payload_view view =
+				lttng_payload_view_from_payload(
+						&trigger_payload, 0, -1);
+
+		if (lttng_trigger_create_from_payload(&view, &trigger) !=
+				trigger_len) {
+			ERR("Invalid trigger payload received in \"register trigger\" command");
+			ret = LTTNG_ERR_INVALID_TRIGGER;
+			goto end;
+		}
 	}
 
+	/* Set the trigger credential */
+	lttng_trigger_set_credentials(trigger, &cmd_creds);
+
+	/* Inform the notification thread */
 	ret = notification_thread_command_register_trigger(notification_thread,
 			trigger);
 	/* Ownership of trigger was transferred. */
 	trigger = NULL;
 end:
 	lttng_trigger_destroy(trigger);
-	lttng_dynamic_buffer_reset(&trigger_buffer);
+	lttng_payload_reset(&trigger_payload);
 	return ret;
 }
 
@@ -4335,19 +4335,23 @@ int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock,
 	size_t trigger_len;
 	ssize_t sock_recv_len;
 	struct lttng_trigger *trigger = NULL;
-	struct lttng_buffer_view view;
-	struct lttng_dynamic_buffer trigger_buffer;
+	struct lttng_payload trigger_payload;
+	struct lttng_credentials cmd_creds = {
+		.uid = cmd_ctx->creds.uid,
+		.gid = cmd_ctx->creds.gid,
+	};
 
-	lttng_dynamic_buffer_init(&trigger_buffer);
-	trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
-	ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
+	lttng_payload_init(&trigger_payload);
+	trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length;
+	ret = lttng_dynamic_buffer_set_size(
+			&trigger_payload.buffer, trigger_len);
 	if (ret) {
 		ret = LTTNG_ERR_NOMEM;
 		goto end;
 	}
 
-	sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
-			trigger_len);
+	sock_recv_len = lttcomm_recv_unix_sock(
+			sock, trigger_payload.buffer.data, trigger_len);
 	if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
 		ERR("Failed to receive \"unregister trigger\" command payload");
 		/* TODO: should this be a new error enum ? */
@@ -4355,19 +4359,39 @@ int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock,
 		goto end;
 	}
 
-	view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
-	if (lttng_trigger_create_from_buffer(&view, &trigger) !=
-			trigger_len) {
-		ERR("Invalid trigger payload received in \"unregister trigger\" command");
-		ret = LTTNG_ERR_INVALID_TRIGGER;
-		goto end;
+	/* Receive fds, if any. */
+	if (cmd_ctx->lsm.fd_count > 0) {
+		ret = lttcomm_recv_payload_fds_unix_sock(
+				sock, cmd_ctx->lsm.fd_count, &trigger_payload);
+		if (ret > 0 && ret != cmd_ctx->lsm.fd_count * sizeof(int)) {
+			ret = LTTNG_ERR_INVALID_PROTOCOL;
+			goto end;
+		} else if (ret <= 0) {
+			ret = LTTNG_ERR_FATAL;
+			goto end;
+		}
+	}
+
+	{
+		struct lttng_payload_view view =
+				lttng_payload_view_from_payload(
+						&trigger_payload, 0, -1);
+
+		if (lttng_trigger_create_from_payload(&view, &trigger) !=
+				trigger_len) {
+			ERR("Invalid trigger payload received in \"unregister trigger\" command");
+			ret = LTTNG_ERR_INVALID_TRIGGER;
+			goto end;
+		}
 	}
 
+	lttng_trigger_set_credentials(trigger, &cmd_creds);
+
 	ret = notification_thread_command_unregister_trigger(notification_thread,
 			trigger);
 end:
 	lttng_trigger_destroy(trigger);
-	lttng_dynamic_buffer_reset(&trigger_buffer);
+	lttng_payload_reset(&trigger_payload);
 	return ret;
 }
 
@@ -4687,7 +4711,7 @@ enum lttng_error_code snapshot_record(struct ltt_session *session,
 			snapshot_output->max_size);
 	if (nb_packets_per_stream < 0) {
 		ret_code = LTTNG_ERR_MAX_SIZE_INVALID;
-		goto error;
+		goto error_close_trace_chunk;
 	}
 
 	if (session->kernel_session) {
@@ -4695,7 +4719,7 @@ enum lttng_error_code snapshot_record(struct ltt_session *session,
 				snapshot_kernel_consumer_output, session,
 				wait, nb_packets_per_stream);
 		if (ret_code != LTTNG_OK) {
-			goto error;
+			goto error_close_trace_chunk;
 		}
 	}
 
@@ -4704,10 +4728,11 @@ enum lttng_error_code snapshot_record(struct ltt_session *session,
 				snapshot_ust_consumer_output, session,
 				wait, nb_packets_per_stream);
 		if (ret_code != LTTNG_OK) {
-			goto error;
+			goto error_close_trace_chunk;
 		}
 	}
 
+error_close_trace_chunk:
 	if (session_set_trace_chunk(session, NULL, &snapshot_trace_chunk)) {
 		ERR("Failed to release the current trace chunk of session \"%s\"",
 				session->name);
@@ -4985,7 +5010,7 @@ int cmd_rotate_session(struct ltt_session *session,
 			cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
 			goto error;
 		}
-        }
+	}
 
 	/*
 	 * The current trace chunk becomes the chunk being archived.