X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fnotification-thread-events.c;h=40450304297230b96cdf980afde1b516dc6c02c9;hp=ff810decec454228d7bc594410e811eef9ee211b;hb=f8522f5cc357c0d80257d5ace1cd556a88305c0c;hpb=6c24d3fd5ade8231445e720c174afe3da4210179

diff --git a/src/bin/lttng-sessiond/notification-thread-events.c b/src/bin/lttng-sessiond/notification-thread-events.c
index ff810dece..404503042 100644
--- a/src/bin/lttng-sessiond/notification-thread-events.c
+++ b/src/bin/lttng-sessiond/notification-thread-events.c
@@ -27,6 +27,7 @@
 #include <lttng/condition/session-consumed-size-internal.h>
 #include <lttng/condition/session-rotation-internal.h>
 #include <lttng/notification/channel-internal.h>
+#include <lttng/trigger/trigger-internal.h>
 
 #include <time.h>
 #include <unistd.h>
@@ -110,6 +111,7 @@ struct lttng_session_trigger_list {
 struct lttng_trigger_ht_element {
 	struct lttng_trigger *trigger;
 	struct cds_lfht_node node;
+	struct cds_lfht_node node_by_name_uid;
 	/* call_rcu delayed reclaim. */
 	struct rcu_head rcu_node;
 };
@@ -187,6 +189,9 @@ int client_handle_transmission_status(
 		enum client_transmission_status transmission_status,
 		struct notification_thread_state *state);
 
+static
+void free_lttng_trigger_ht_element_rcu(struct rcu_head *node);
+
 static
 int match_client_socket(struct cds_lfht_node *node, const void *key)
 {
@@ -261,18 +266,15 @@ int match_channel_info(struct cds_lfht_node *node, const void *key)
 }
 
 static
-int match_condition(struct cds_lfht_node *node, const void *key)
+int match_trigger(struct cds_lfht_node *node, const void *key)
 {
-	struct lttng_condition *condition_key = (struct lttng_condition *) key;
-	struct lttng_trigger_ht_element *trigger;
-	struct lttng_condition *condition;
+	struct lttng_trigger *trigger_key = (struct lttng_trigger *) key;
+	struct lttng_trigger_ht_element *trigger_ht_element;
 
-	trigger = caa_container_of(node, struct lttng_trigger_ht_element,
+	trigger_ht_element = caa_container_of(node, struct lttng_trigger_ht_element,
 			node);
-	condition = lttng_trigger_get_condition(trigger->trigger);
-	assert(condition);
 
-	return !!lttng_condition_is_equal(condition_key, condition);
+	return !!lttng_trigger_is_equal(trigger_key, trigger_ht_element->trigger);
 }
 
 static
@@ -301,6 +303,71 @@ int match_session(struct cds_lfht_node *node, const void *key)
 	return !strcmp(session_info->name, name);
 }
 
+/*
+ * Match trigger based on name and credentials only.
+ * Name duplication is NOT allowed for the same uid.
+ */
+static
+int match_trigger_by_name_uid(struct cds_lfht_node *node,
+		const void *key)
+{
+	bool match = false;
+	const char *name;
+	const char *key_name;
+	enum lttng_trigger_status status;
+	const struct lttng_credentials *key_creds;
+	const struct lttng_credentials *node_creds;
+	const struct lttng_trigger *trigger_key =
+			(const struct lttng_trigger *) key;
+	const struct lttng_trigger_ht_element *trigger_ht_element =
+			caa_container_of(node,
+				struct lttng_trigger_ht_element,
+				node_by_name_uid);
+
+	status = lttng_trigger_get_name(trigger_ht_element->trigger, &name);
+	assert(status == LTTNG_TRIGGER_STATUS_OK);
+
+	status = lttng_trigger_get_name(trigger_key, &key_name);
+	assert(status == LTTNG_TRIGGER_STATUS_OK);
+
+	/* Compare the names. */
+	if (strcmp(name, key_name) != 0) {
+		goto end;
+	}
+
+	/* Compare the owners' UIDs. */
+	key_creds = lttng_trigger_get_credentials(trigger_key);
+	node_creds = lttng_trigger_get_credentials(trigger_ht_element->trigger);
+
+	match = lttng_credentials_is_equal_uid(key_creds, node_creds);
+
+end:
+	return match;
+}
+
+/*
+ * Hash trigger based on name and credentials only.
+ */
+static
+unsigned long hash_trigger_by_name_uid(const struct lttng_trigger *trigger)
+{
+	unsigned long hash = 0;
+	const struct lttng_credentials *trigger_creds;
+	const char *trigger_name;
+	enum lttng_trigger_status status;
+
+	status = lttng_trigger_get_name(trigger, &trigger_name);
+	if (status == LTTNG_TRIGGER_STATUS_OK) {
+		hash = hash_key_str(trigger_name, lttng_ht_seed);
+	}
+
+	trigger_creds = lttng_trigger_get_credentials(trigger);
+	hash ^= hash_key_ulong((void *) (unsigned long) LTTNG_OPTIONAL_GET(trigger_creds->uid),
+			lttng_ht_seed);
+
+	return hash;
+}
+
 static
 unsigned long lttng_condition_buffer_usage_hash(
 	const struct lttng_condition *_condition)
@@ -1184,8 +1251,8 @@ void notification_client_destroy(struct notification_client *client,
 		client->socket = -1;
 	}
 	client->communication.active = false;
-	lttng_dynamic_buffer_reset(&client->communication.inbound.buffer);
-	lttng_dynamic_buffer_reset(&client->communication.outbound.buffer);
+	lttng_payload_reset(&client->communication.inbound.payload);
+	lttng_payload_reset(&client->communication.outbound.payload);
 	pthread_mutex_destroy(&client->lock);
 	call_rcu(&client->rcu_node, free_notification_client_rcu);
 }
@@ -1807,8 +1874,8 @@ int handle_notification_thread_command_session_rotation(
 	struct lttng_trigger_list_element *trigger_list_element;
 	struct session_info *session_info;
 	const struct lttng_credentials session_creds = {
-		.uid = session_uid,
-		.gid = session_gid,
+		.uid = LTTNG_OPTIONAL_INIT_VALUE(session_uid),
+		.gid = LTTNG_OPTIONAL_INIT_VALUE(session_gid),
 	};
 
 	rcu_read_lock();
@@ -2058,7 +2125,7 @@ bool is_trigger_action_notify(const struct lttng_trigger *trigger)
 	enum lttng_action_type action_type;
 
 	assert(action);
-	action_type = lttng_action_get_type_const(action);
+	action_type = lttng_action_get_type(action);
 	if (action_type == LTTNG_ACTION_TYPE_NOTIFY) {
 		is_notify = true;
 		goto end;
@@ -2074,7 +2141,7 @@ bool is_trigger_action_notify(const struct lttng_trigger *trigger)
 				lttng_action_group_get_at_index(
 						action, i);
 
-		action_type = lttng_action_get_type_const(inner_action);
+		action_type = lttng_action_get_type(inner_action);
 		if (action_type == LTTNG_ACTION_TYPE_NOTIFY) {
 			is_notify = true;
 			goto end;
@@ -2085,6 +2152,50 @@ end:
 	return is_notify;
 }
 
+static bool trigger_name_taken(struct notification_thread_state *state,
+		const struct lttng_trigger *trigger)
+{
+	struct cds_lfht_iter iter;
+
+	/*
+	 * No duplicata is allowed in the triggers_by_name_uid_ht.
+	 * The match is done against the trigger name and uid.
+	 */
+	cds_lfht_lookup(state->triggers_by_name_uid_ht,
+			hash_trigger_by_name_uid(trigger),
+			match_trigger_by_name_uid,
+			trigger,
+			&iter);
+	return !!cds_lfht_iter_get_node(&iter);
+}
+
+static
+enum lttng_error_code generate_trigger_name(
+		struct notification_thread_state *state,
+		struct lttng_trigger *trigger, const char **name)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+	bool taken = false;
+	enum lttng_trigger_status status;
+
+	do {
+		const int ret = lttng_trigger_generate_name(trigger,
+				state->trigger_id.name_offset++);
+		if (ret) {
+			/* The only reason this can fail right now. */
+			ret_code = LTTNG_ERR_NOMEM;
+			break;
+		}
+
+		status = lttng_trigger_get_name(trigger, name);
+		assert(status == LTTNG_TRIGGER_STATUS_OK);
+
+		taken = trigger_name_taken(state, trigger);
+	} while (taken || state->trigger_id.name_offset == UINT64_MAX);
+
+	return ret_code;
+}
+
 /*
  * FIXME A client's credentials are not checked when registering a trigger.
  *
@@ -2114,13 +2225,39 @@ int handle_notification_thread_command_register_trigger(
 	struct notification_client_list_element *client_list_element;
 	struct cds_lfht_node *node;
 	struct cds_lfht_iter iter;
+	const char* trigger_name;
 	bool free_trigger = true;
 	struct lttng_evaluation *evaluation = NULL;
 	struct lttng_credentials object_creds;
+	uid_t object_uid;
+	gid_t object_gid;
 	enum action_executor_status executor_status;
+	const uint64_t trigger_tracer_token =
+			state->trigger_id.next_tracer_token++;
 
 	rcu_read_lock();
 
+	/* Set the trigger's tracer token. */
+	lttng_trigger_set_tracer_token(trigger, trigger_tracer_token);
+
+	if (lttng_trigger_get_name(trigger, &trigger_name) ==
+			LTTNG_TRIGGER_STATUS_UNSET) {
+		const enum lttng_error_code ret_code = generate_trigger_name(
+				state, trigger, &trigger_name);
+
+		if (ret_code != LTTNG_OK) {
+			/* Fatal error. */
+			ret = -1;
+			*cmd_result = ret_code;
+			goto error;
+		}
+	} else if (trigger_name_taken(state, trigger)) {
+		/* Not a fatal error. */
+		*cmd_result = LTTNG_ERR_TRIGGER_EXISTS;
+		ret = 0;
+		goto error;
+	}
+
 	condition = lttng_trigger_get_condition(trigger);
 	assert(condition);
 
@@ -2143,12 +2280,13 @@ int handle_notification_thread_command_register_trigger(
 
 	/* Add trigger to the trigger_ht. */
 	cds_lfht_node_init(&trigger_ht_element->node);
+	cds_lfht_node_init(&trigger_ht_element->node_by_name_uid);
 	trigger_ht_element->trigger = trigger;
 
 	node = cds_lfht_add_unique(state->triggers_ht,
 			lttng_condition_hash(condition),
-			match_condition,
-			condition,
+			match_trigger,
+			trigger,
 			&trigger_ht_element->node);
 	if (node != &trigger_ht_element->node) {
 		/* Not a fatal error, simply report it to the client. */
@@ -2156,6 +2294,18 @@ int handle_notification_thread_command_register_trigger(
 		goto error_free_ht_element;
 	}
 
+	node = cds_lfht_add_unique(state->triggers_by_name_uid_ht,
+			hash_trigger_by_name_uid(trigger),
+			match_trigger_by_name_uid,
+			trigger,
+			&trigger_ht_element->node_by_name_uid);
+	if (node != &trigger_ht_element->node_by_name_uid) {
+		/* Not a fatal error, simply report it to the client. */
+		cds_lfht_del(state->triggers_ht, &trigger_ht_element->node);
+		*cmd_result = LTTNG_ERR_TRIGGER_EXISTS;
+		goto error_free_ht_element;
+	}
+
 	/*
 	 * Ownership of the trigger and of its wrapper was transfered to
 	 * the triggers_ht.
@@ -2260,21 +2410,21 @@ int handle_notification_thread_command_register_trigger(
 	switch (get_condition_binding_object(condition)) {
 	case LTTNG_OBJECT_TYPE_SESSION:
 		ret = evaluate_session_condition_for_client(condition, state,
-				&evaluation, &object_creds.uid,
-				&object_creds.gid);
+				&evaluation, &object_uid,
+				&object_gid);
 		break;
 	case LTTNG_OBJECT_TYPE_CHANNEL:
 		ret = evaluate_channel_condition_for_client(condition, state,
-				&evaluation, &object_creds.uid,
-				&object_creds.gid);
+				&evaluation, &object_uid,
+				&object_gid);
 		break;
 	case LTTNG_OBJECT_TYPE_NONE:
 		ret = 0;
-		goto error_put_client_list;
+		break;
 	case LTTNG_OBJECT_TYPE_UNKNOWN:
 	default:
 		ret = -1;
-		goto error_put_client_list;
+		break;
 	}
 
 	if (ret) {
@@ -2282,12 +2432,15 @@ int handle_notification_thread_command_register_trigger(
 		goto error_put_client_list;
 	}
 
+	LTTNG_OPTIONAL_SET(&object_creds.uid, object_uid);
+	LTTNG_OPTIONAL_SET(&object_creds.gid, object_gid);
+
 	DBG("Newly registered trigger's condition evaluated to %s",
 			evaluation ? "true" : "false");
 	if (!evaluation) {
 		/* Evaluation yielded nothing. Normal exit. */
 		ret = 0;
-		goto error_put_client_list;
+		goto end;
 	}
 
 	/*
@@ -2318,18 +2471,26 @@ int handle_notification_thread_command_register_trigger(
 		 */
 		WARN("No space left when enqueuing action associated to newly registered trigger");
 		ret = 0;
-		goto error_put_client_list;
+		goto end;
 	default:
 		abort();
 	}
 
+end:
 	*cmd_result = LTTNG_OK;
+	DBG("Registered trigger: name = `%s`, tracer token = %" PRIu64,
+			trigger_name, trigger_tracer_token);
 
 error_put_client_list:
 	notification_client_list_put(client_list);
 
 error_free_ht_element:
-	free(trigger_ht_element);
+	if (trigger_ht_element) {
+		/* Delayed removal due to RCU constraint on delete. */
+		call_rcu(&trigger_ht_element->rcu_node,
+				free_lttng_trigger_ht_element_rcu);
+	}
+
 error:
 	if (free_trigger) {
 		lttng_trigger_destroy(trigger);
@@ -2364,8 +2525,8 @@ int handle_notification_thread_command_unregister_trigger(
 
 	cds_lfht_lookup(state->triggers_ht,
 			lttng_condition_hash(condition),
-			match_condition,
-			condition,
+			match_trigger,
+			trigger,
 			&iter);
 	triggers_ht_node = cds_lfht_iter_get_node(&iter);
 	if (!triggers_ht_node) {
@@ -2414,6 +2575,7 @@ int handle_notification_thread_command_unregister_trigger(
 	/* Remove trigger from triggers_ht. */
 	trigger_ht_element = caa_container_of(triggers_ht_node,
 			struct lttng_trigger_ht_element, node);
+	cds_lfht_del(state->triggers_by_name_uid_ht, &trigger_ht_element->node_by_name_uid);
 	cds_lfht_del(state->triggers_ht, triggers_ht_node);
 
 	/* Release the ownership of the trigger. */
@@ -2582,9 +2744,8 @@ int client_reset_inbound_state(struct notification_client *client)
 {
 	int ret;
 
-	ret = lttng_dynamic_buffer_set_size(
-			&client->communication.inbound.buffer, 0);
-	assert(!ret);
+
+	lttng_payload_clear(&client->communication.inbound.payload);
 
 	client->communication.inbound.bytes_to_receive =
 			sizeof(struct lttng_notification_channel_message);
@@ -2593,8 +2754,9 @@ int client_reset_inbound_state(struct notification_client *client)
 	LTTNG_SOCK_SET_UID_CRED(&client->communication.inbound.creds, -1);
 	LTTNG_SOCK_SET_GID_CRED(&client->communication.inbound.creds, -1);
 	ret = lttng_dynamic_buffer_set_size(
-			&client->communication.inbound.buffer,
+			&client->communication.inbound.payload.buffer,
 			client->communication.inbound.bytes_to_receive);
+
 	return ret;
 }
 
@@ -2616,8 +2778,8 @@ int handle_notification_thread_client_connect(
 	pthread_mutex_init(&client->lock, NULL);
 	client->id = state->next_notification_client_id++;
 	CDS_INIT_LIST_HEAD(&client->condition_list);
-	lttng_dynamic_buffer_init(&client->communication.inbound.buffer);
-	lttng_dynamic_buffer_init(&client->communication.outbound.buffer);
+	lttng_payload_init(&client->communication.inbound.payload);
+	lttng_payload_init(&client->communication.outbound.payload);
 	client->communication.inbound.expect_creds = true;
 
 	ret = client_reset_inbound_state(client);
@@ -2835,6 +2997,10 @@ enum client_transmission_status client_flush_outgoing_queue(
 	ssize_t ret;
 	size_t to_send_count;
 	enum client_transmission_status status;
+	struct lttng_payload_view pv = lttng_payload_view_from_payload(
+			&client->communication.outbound.payload, 0, -1);
+	const int fds_to_send_count =
+			lttng_payload_view_get_fd_handle_count(&pv);
 
 	ASSERT_LOCKED(client->lock);
 
@@ -2843,55 +3009,121 @@ enum client_transmission_status client_flush_outgoing_queue(
 		goto end;
 	}
 
-	assert(client->communication.outbound.buffer.size != 0);
-	to_send_count = client->communication.outbound.buffer.size;
+	if (pv.buffer.size == 0) {
+		/*
+		 * If both data and fds are equal to zero, we are in an invalid
+		 * state.
+		 */
+		assert(fds_to_send_count != 0);
+		goto send_fds;
+	}
+
+	/* Send data. */
+	to_send_count = pv.buffer.size;
 	DBG("[notification-thread] Flushing client (socket fd = %i) outgoing queue",
 			client->socket);
 
 	ret = lttcomm_send_unix_sock_non_block(client->socket,
-			client->communication.outbound.buffer.data,
+			pv.buffer.data,
 			to_send_count);
 	if ((ret >= 0 && ret < to_send_count)) {
 		DBG("[notification-thread] Client (socket fd = %i) outgoing queue could not be completely flushed",
 				client->socket);
 		to_send_count -= max(ret, 0);
 
-		memcpy(client->communication.outbound.buffer.data,
-				client->communication.outbound.buffer.data +
-				client->communication.outbound.buffer.size - to_send_count,
+		memmove(client->communication.outbound.payload.buffer.data,
+				pv.buffer.data +
+				pv.buffer.size - to_send_count,
 				to_send_count);
 		ret = lttng_dynamic_buffer_set_size(
-				&client->communication.outbound.buffer,
+				&client->communication.outbound.payload.buffer,
 				to_send_count);
 		if (ret) {
 			goto error;
 		}
 
 		status = CLIENT_TRANSMISSION_STATUS_QUEUED;
+		goto end;
 	} else if (ret < 0) {
 		/* Generic error, disable the client's communication. */
 		ERR("[notification-thread] Failed to flush outgoing queue, disconnecting client (socket fd = %i)",
 				client->socket);
 		client->communication.active = false;
 		status = CLIENT_TRANSMISSION_STATUS_FAIL;
+		goto end;
 	} else {
-		/* No error and flushed the queue completely. */
+		/*
+		 * No error and flushed the queue completely.
+		 *
+		 * The payload buffer size is used later to
+		 * check if there is notifications queued. So albeit that the
+		 * direct caller knows that the transmission is complete, we
+		 * need to set the buffer size to zero.
+		 */
 		ret = lttng_dynamic_buffer_set_size(
-				&client->communication.outbound.buffer, 0);
+				&client->communication.outbound.payload.buffer, 0);
 		if (ret) {
 			goto error;
 		}
+	}
 
-		client->communication.outbound.queued_command_reply = false;
-		client->communication.outbound.dropped_notification = false;
+send_fds:
+	/* No fds to send, transmission is complete. */
+	if (fds_to_send_count == 0) {
 		status = CLIENT_TRANSMISSION_STATUS_COMPLETE;
+		goto end;
 	}
+
+	ret = lttcomm_send_payload_view_fds_unix_sock_non_block(
+			client->socket, &pv);
+	if (ret < 0) {
+		/* Generic error, disable the client's communication. */
+		ERR("[notification-thread] Failed to flush outgoing fds queue, disconnecting client (socket fd = %i)",
+				client->socket);
+		client->communication.active = false;
+		status = CLIENT_TRANSMISSION_STATUS_FAIL;
+		goto end;
+	} else if (ret == 0) {
+		/* Nothing could be sent. */
+		status = CLIENT_TRANSMISSION_STATUS_QUEUED;
+	} else {
+		/* Fd passing is an all or nothing kind of thing. */
+		status = CLIENT_TRANSMISSION_STATUS_COMPLETE;
+		/*
+		 * The payload _fd_array count is used later to
+		 * check if there is notifications queued. So although the
+		 * direct caller knows that the transmission is complete, we
+		 * need to clear the _fd_array for the queuing check.
+		 */
+		lttng_dynamic_pointer_array_clear(
+				&client->communication.outbound.payload
+						 ._fd_handles);
+	}
+
 end:
+	if (status == CLIENT_TRANSMISSION_STATUS_COMPLETE) {
+		client->communication.outbound.queued_command_reply = false;
+		client->communication.outbound.dropped_notification = false;
+		lttng_payload_clear(&client->communication.outbound.payload);
+	}
+
 	return status;
 error:
 	return CLIENT_TRANSMISSION_STATUS_ERROR;
 }
 
+static
+bool client_has_outbound_data_left(
+		const struct notification_client *client)
+{
+	const struct lttng_payload_view pv = lttng_payload_view_from_payload(
+			&client->communication.outbound.payload, 0, -1);
+	const bool has_data = pv.buffer.size != 0;
+	const bool has_fds = lttng_payload_view_get_fd_handle_count(&pv);
+
+	return has_data || has_fds;
+}
+
 /* Client lock must _not_ be held by the caller. */
 static
 int client_send_command_reply(struct notification_client *client,
@@ -2921,14 +3153,15 @@ int client_send_command_reply(struct notification_client *client,
 
 	/* Enqueue buffer to outgoing queue and flush it. */
 	ret = lttng_dynamic_buffer_append(
-			&client->communication.outbound.buffer,
+			&client->communication.outbound.payload.buffer,
 			buffer, sizeof(buffer));
 	if (ret) {
 		goto error_unlock;
 	}
 
 	transmission_status = client_flush_outgoing_queue(client);
-	if (client->communication.outbound.buffer.size != 0) {
+
+	if (client_has_outbound_data_left(client)) {
 		/* Queue could not be emptied. */
 		client->communication.outbound.queued_command_reply = true;
 	}
@@ -2959,9 +3192,9 @@ int client_handle_message_unknown(struct notification_client *client,
 	 */
 	const struct lttng_notification_channel_message *msg;
 
-	assert(sizeof(*msg) == client->communication.inbound.buffer.size);
+	assert(sizeof(*msg) == client->communication.inbound.payload.buffer.size);
 	msg = (const struct lttng_notification_channel_message *)
-			      client->communication.inbound.buffer.data;
+			      client->communication.inbound.payload.buffer.data;
 
 	if (msg->size == 0 ||
 			msg->size > DEFAULT_MAX_NOTIFICATION_CLIENT_MESSAGE_PAYLOAD_SIZE) {
@@ -2983,10 +3216,14 @@ int client_handle_message_unknown(struct notification_client *client,
 	}
 
 	client->communication.inbound.bytes_to_receive = msg->size;
+	client->communication.inbound.fds_to_receive = msg->fds;
 	client->communication.inbound.msg_type =
 			(enum lttng_notification_channel_message_type) msg->type;
 	ret = lttng_dynamic_buffer_set_size(
-			&client->communication.inbound.buffer, msg->size);
+			&client->communication.inbound.payload.buffer, msg->size);
+
+	/* msg is not valid anymore due to lttng_dynamic_buffer_set_size. */
+	msg = NULL;
 end:
 	return ret;
 }
@@ -3015,7 +3252,7 @@ int client_handle_message_handshake(struct notification_client *client,
 
 	handshake_client =
 			(struct lttng_notification_channel_command_handshake *)
-					client->communication.inbound.buffer
+					client->communication.inbound.payload.buffer
 							.data;
 	client->major = handshake_client->major;
 	client->minor = handshake_client->minor;
@@ -3041,7 +3278,7 @@ int client_handle_message_handshake(struct notification_client *client,
 	pthread_mutex_lock(&client->lock);
 	/* Outgoing queue will be flushed when the command reply is sent. */
 	ret = lttng_dynamic_buffer_append(
-			&client->communication.outbound.buffer, send_buffer,
+			&client->communication.outbound.payload.buffer, send_buffer,
 			sizeof(send_buffer));
 	if (ret) {
 		ERR("[notification-thread] Failed to send protocol version to notification channel client");
@@ -3084,8 +3321,8 @@ int client_handle_message_subscription(
 	enum lttng_notification_channel_status status =
 			LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
 	struct lttng_payload_view condition_view =
-			lttng_payload_view_from_dynamic_buffer(
-					&client->communication.inbound.buffer,
+			lttng_payload_view_from_payload(
+					&client->communication.inbound.payload,
 					0, -1);
 	size_t expected_condition_size;
 
@@ -3094,7 +3331,7 @@ int client_handle_message_subscription(
 	 * other thread accessing clients (action executor) only uses the
 	 * outbound state.
 	 */
-	expected_condition_size = client->communication.inbound.buffer.size;
+	expected_condition_size = client->communication.inbound.payload.buffer.size;
 	ret = lttng_condition_create_from_payload(&condition_view, &condition);
 	if (ret != expected_condition_size) {
 		ERR("[notification-thread] Malformed condition received from client");
@@ -3179,7 +3416,6 @@ int handle_notification_thread_client_in(
 	struct notification_client *client;
 	ssize_t recv_ret;
 	size_t offset;
-	bool message_is_complete = false;
 
 	rcu_read_lock();
 	client = get_client_from_socket(socket, state);
@@ -3189,11 +3425,11 @@ int handle_notification_thread_client_in(
 		goto end;
 	}
 
-	offset = client->communication.inbound.buffer.size -
+	offset = client->communication.inbound.payload.buffer.size -
 			client->communication.inbound.bytes_to_receive;
 	if (client->communication.inbound.expect_creds) {
 		recv_ret = lttcomm_recv_creds_unix_sock(socket,
-				client->communication.inbound.buffer.data + offset,
+				client->communication.inbound.payload.buffer.data + offset,
 				client->communication.inbound.bytes_to_receive,
 				&client->communication.inbound.creds);
 		if (recv_ret > 0) {
@@ -3202,32 +3438,66 @@ int handle_notification_thread_client_in(
 		}
 	} else {
 		recv_ret = lttcomm_recv_unix_sock_non_block(socket,
-				client->communication.inbound.buffer.data + offset,
+				client->communication.inbound.payload.buffer.data + offset,
 				client->communication.inbound.bytes_to_receive);
 	}
 	if (recv_ret >= 0) {
 		client->communication.inbound.bytes_to_receive -= recv_ret;
-		message_is_complete = client->communication.inbound
-						      .bytes_to_receive == 0;
+	} else {
+		goto error_disconnect_client;
 	}
 
-	if (recv_ret < 0) {
-		goto error_disconnect_client;
+	if (client->communication.inbound.bytes_to_receive != 0) {
+		/* Message incomplete wait for more data. */
+		ret = 0;
+		goto end;
 	}
 
-	if (message_is_complete) {
-		ret = client_dispatch_message(client, state);
-		if (ret) {
+	assert(client->communication.inbound.bytes_to_receive == 0);
+
+	/* Receive fds. */
+	if (client->communication.inbound.fds_to_receive != 0) {
+		ret = lttcomm_recv_payload_fds_unix_sock_non_block(
+				client->socket,
+				client->communication.inbound.fds_to_receive,
+				&client->communication.inbound.payload);
+		if (ret > 0) {
 			/*
-			 * Only returns an error if this client must be
-			 * disconnected.
+			 * Fds received. non blocking fds passing is all
+			 * or nothing.
 			 */
+			ssize_t expected_size;
+
+			expected_size = sizeof(int) *
+					client->communication.inbound
+							.fds_to_receive;
+			assert(ret == expected_size);
+			client->communication.inbound.fds_to_receive = 0;
+		} else if (ret == 0) {
+			/* Received nothing. */
+			ret = 0;
+			goto end;
+		} else {
 			goto error_disconnect_client;
 		}
 	}
+
+	/* At this point the message is complete.*/
+	assert(client->communication.inbound.bytes_to_receive == 0 &&
+			client->communication.inbound.fds_to_receive == 0);
+	ret = client_dispatch_message(client, state);
+	if (ret) {
+		/*
+		 * Only returns an error if this client must be
+		 * disconnected.
+		 */
+		goto error_disconnect_client;
+	}
+
 end:
 	rcu_read_unlock();
 	return ret;
+
 error_disconnect_client:
 	ret = notification_thread_client_disconnect(client, state);
 	goto end;
@@ -3448,7 +3718,7 @@ int client_notification_overflow(struct notification_client *client)
 
 	client->communication.outbound.dropped_notification = true;
 	ret = lttng_dynamic_buffer_append(
-			&client->communication.outbound.buffer, &msg,
+			&client->communication.outbound.payload.buffer, &msg,
 			sizeof(msg));
 	if (ret) {
 		PERROR("Failed to enqueue \"dropped notification\" message in client's (socket fd = %i) outgoing queue",
@@ -3474,11 +3744,15 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
 		struct notification_thread_state *state,
 		uid_t object_uid, gid_t object_gid)
 {
+	const struct lttng_credentials creds = {
+		.uid = LTTNG_OPTIONAL_INIT_VALUE(object_uid),
+		.gid = LTTNG_OPTIONAL_INIT_VALUE(object_gid),
+	};
+
 	return notification_client_list_send_evaluation(client_list,
 			lttng_trigger_get_const_condition(trigger), evaluation,
 			lttng_trigger_get_credentials(trigger),
-			&(struct lttng_credentials){
-					.uid = object_uid, .gid = object_gid},
+			&creds,
 			client_handle_transmission_status_wrapper, state);
 }
 
@@ -3556,6 +3830,16 @@ int notification_client_list_send_evaluation(
 			->size = (uint32_t)(
 			msg_payload.buffer.size - sizeof(msg_header));
 
+	/* Update the payload number of fds. */
+	{
+		const struct lttng_payload_view pv = lttng_payload_view_from_payload(
+				&msg_payload, 0, -1);
+
+		((struct lttng_notification_channel_message *)
+				msg_payload.buffer.data)->fds = (uint32_t)
+				lttng_payload_view_get_fd_handle_count(&pv);
+	}
+
 	pthread_mutex_lock(&client_list->lock);
 	cds_list_for_each_entry_safe(client_list_element, tmp,
 			&client_list->list, node) {
@@ -3575,8 +3859,8 @@ int notification_client_list_send_evaluation(
 		}
 
 		if (source_object_creds) {
-			if (client->uid != source_object_creds->uid &&
-					client->gid != source_object_creds->gid &&
+			if (client->uid != lttng_credentials_get_uid(source_object_creds) &&
+					client->gid != lttng_credentials_get_gid(source_object_creds) &&
 					client->uid != 0) {
 				/*
 				 * Client is not allowed to monitor this
@@ -3587,14 +3871,15 @@ int notification_client_list_send_evaluation(
 			}
 		}
 
-		if (client->uid != trigger_creds->uid && client->gid != trigger_creds->gid) {
+		if (client->uid != lttng_credentials_get_uid(trigger_creds) && client->gid != lttng_credentials_get_gid(trigger_creds)) {
 			DBG("[notification-thread] Skipping client at it does not have the permission to receive notification for this trigger");
 			goto skip_client;
 		}
 
 		DBG("[notification-thread] Sending notification to client (fd = %i, %zu bytes)",
 				client->socket, msg_payload.buffer.size);
-		if (client->communication.outbound.buffer.size) {
+
+		if (client_has_outbound_data_left(client)) {
 			/*
 			 * Outgoing data is already buffered for this client;
 			 * drop the notification and enqueue a "dropped
@@ -3609,9 +3894,7 @@ int notification_client_list_send_evaluation(
 			}
 		}
 
-		ret = lttng_dynamic_buffer_append_buffer(
-				&client->communication.outbound.buffer,
-				&msg_payload.buffer);
+		ret = lttng_payload_copy(&msg_payload, &client->communication.outbound.payload);
 		if (ret) {
 			/* Fatal error. */
 			goto skip_client;
@@ -3777,8 +4060,8 @@ int handle_notification_thread_channel_sample(
 	}
 
 	channel_creds = (typeof(channel_creds)) {
-		.uid = channel_info->session_info->uid,
-		.gid = channel_info->session_info->gid,
+		.uid = LTTNG_OPTIONAL_INIT_VALUE(channel_info->session_info->uid),
+		.gid = LTTNG_OPTIONAL_INIT_VALUE(channel_info->session_info->gid),
 	};
 
 	trigger_list = caa_container_of(node, struct lttng_channel_trigger_list,
@@ -3816,6 +4099,12 @@ int handle_notification_thread_channel_sample(
 			goto put_list;
 		}
 
+		if (!lttng_trigger_should_fire(trigger)) {
+			goto put_list;
+		}
+
+		lttng_trigger_fire(trigger);
+
 		/*
 		 * Ownership of `evaluation` transferred to the action executor
 		 * no matter the result.