X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-app.c;h=50d2f1932657e56f7863e5b23fd3ef8b48cad87d;hp=38d1d78713e6446dca9b55b001ccfbee376c88b3;hb=a84d10248d99b14e8758011fbe82344b19b258b7;hpb=5d4193fd103743e68020148db71469b907020140

diff --git a/src/bin/lttng-sessiond/ust-app.c b/src/bin/lttng-sessiond/ust-app.c
index 38d1d7871..50d2f1932 100644
--- a/src/bin/lttng-sessiond/ust-app.c
+++ b/src/bin/lttng-sessiond/ust-app.c
@@ -18,6 +18,7 @@
 #include <urcu/compiler.h>
 #include <signal.h>
 
+#include <common/bytecode/bytecode.h>
 #include <common/compat/errno.h>
 #include <common/common.h>
 #include <common/hashtable/utils.h>
@@ -25,8 +26,9 @@
 #include <lttng/event-rule/event-rule-internal.h>
 #include <lttng/event-rule/tracepoint.h>
 #include <lttng/condition/condition.h>
-#include <lttng/condition/event-rule-internal.h>
-#include <lttng/condition/event-rule.h>
+#include <lttng/condition/on-event-internal.h>
+#include <lttng/condition/on-event.h>
+#include <lttng/trigger/trigger-internal.h>
 #include <common/sessiond-comm/sessiond-comm.h>
 
 #include "buffer-registry.h"
@@ -41,6 +43,7 @@
 #include "lttng-sessiond.h"
 #include "notification-thread-commands.h"
 #include "rotate.h"
+#include "event.h"
 
 struct lttng_ht *ust_app_ht;
 struct lttng_ht *ust_app_ht_by_sock;
@@ -85,7 +88,7 @@ static uint64_t get_next_session_id(void)
 
 static void copy_channel_attr_to_ustctl(
 		struct ustctl_consumer_channel_attr *attr,
-		struct lttng_ust_channel_attr *uattr)
+		struct lttng_ust_abi_channel_attr *uattr)
 {
 	/* Copy event attributes since the layout is different. */
 	attr->subbuf_size = uattr->subbuf_size;
@@ -125,7 +128,7 @@ static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
 
 	/* Event loglevel. */
 	if (ev_loglevel_value != key->loglevel_type) {
-		if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
+		if (event->attr.loglevel_type == LTTNG_UST_ABI_LOGLEVEL_ALL
 				&& key->loglevel_type == 0 &&
 				ev_loglevel_value == -1) {
 			/*
@@ -162,7 +165,7 @@ static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
 		/* Both exclusions exists, check count followed by the names. */
 		if (event->exclusion->count != key->exclusion->count ||
 				memcmp(event->exclusion->names, key->exclusion->names,
-					event->exclusion->count * LTTNG_UST_SYM_NAME_LEN) != 0) {
+					event->exclusion->count * LTTNG_UST_ABI_SYM_NAME_LEN) != 0) {
 			goto no_match;
 		}
 	}
@@ -360,7 +363,7 @@ static void delete_ust_app_event_notifier_rule(int sock,
 		free(ua_event_notifier_rule->obj);
 	}
 
-	lttng_event_rule_put(ua_event_notifier_rule->event_rule);
+	lttng_trigger_put(ua_event_notifier_rule->trigger);
 	call_rcu(&ua_event_notifier_rule->rcu_head,
 			free_ust_app_event_notifier_rule_rcu);
 }
@@ -437,7 +440,7 @@ void save_per_pid_lost_discarded_counters(struct ust_app_channel *ua_chan)
 	struct ltt_session *session;
 	struct ltt_ust_channel *uchan;
 
-	if (ua_chan->attr.type != LTTNG_UST_CHAN_PER_CPU) {
+	if (ua_chan->attr.type != LTTNG_UST_ABI_CHAN_PER_CPU) {
 		return;
 	}
 
@@ -577,7 +580,7 @@ int ust_app_register_done(struct ust_app *app)
 	return ret;
 }
 
-int ust_app_release_object(struct ust_app *app, struct lttng_ust_object_data *data)
+int ust_app_release_object(struct ust_app *app, struct lttng_ust_abi_object_data *data)
 {
 	int ret, sock;
 
@@ -952,6 +955,7 @@ void delete_ust_app(struct ust_app *app)
 	struct ust_app_session *ua_sess, *tmp_ua_sess;
 	struct lttng_ht_iter iter;
 	struct ust_app_event_notifier_rule *event_notifier_rule;
+	bool event_notifier_write_fd_is_open;
 
 	/*
 	 * The session list lock must be held during this function to guarantee
@@ -1009,7 +1013,16 @@ void delete_ust_app(struct ust_app *app)
 		free(app->event_notifier_group.object);
 	}
 
+	event_notifier_write_fd_is_open = lttng_pipe_is_write_open(
+			app->event_notifier_group.event_pipe);
 	lttng_pipe_destroy(app->event_notifier_group.event_pipe);
+	/*
+	 * Release the file descriptors reserved for the event notifier pipe.
+	 * The app could be destroyed before the write end of the pipe could be
+	 * passed to the application (and closed). In that case, both file
+	 * descriptors must be released.
+	 */
+	lttng_fd_put(LTTNG_FD_APPS, event_notifier_write_fd_is_open ? 2 : 1);
 
 	/*
 	 * Wait until we have deleted the application from the sock hash table
@@ -1096,7 +1109,7 @@ struct ust_app_session *alloc_ust_app_session(void)
 
 	ua_sess->handle = -1;
 	ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
-	ua_sess->metadata_attr.type = LTTNG_UST_CHAN_METADATA;
+	ua_sess->metadata_attr.type = LTTNG_UST_ABI_CHAN_METADATA;
 	pthread_mutex_init(&ua_sess->lock, NULL);
 
 	return ua_sess;
@@ -1111,7 +1124,7 @@ error_free:
 static
 struct ust_app_channel *alloc_ust_app_channel(const char *name,
 		struct ust_app_session *ua_sess,
-		struct lttng_ust_channel_attr *attr)
+		struct lttng_ust_abi_channel_attr *attr)
 {
 	struct ust_app_channel *ua_chan;
 
@@ -1149,7 +1162,7 @@ struct ust_app_channel *alloc_ust_app_channel(const char *name,
 		ua_chan->attr.blocking_timeout = attr->u.s.blocking_timeout;
 	}
 	/* By default, the channel is a per cpu channel. */
-	ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
+	ua_chan->attr.type = LTTNG_UST_ABI_CHAN_PER_CPU;
 
 	DBG3("UST app channel %s allocated", ua_chan->name);
 
@@ -1186,7 +1199,7 @@ error:
  */
 static
 struct ust_app_event *alloc_ust_app_event(char *name,
-		struct lttng_ust_event *attr)
+		struct lttng_ust_abi_event *attr)
 {
 	struct ust_app_event *ua_event;
 
@@ -1219,11 +1232,13 @@ error:
  * Allocate a new UST app event notifier rule.
  */
 static struct ust_app_event_notifier_rule *alloc_ust_app_event_notifier_rule(
-		struct lttng_event_rule *event_rule, uint64_t token)
+		struct lttng_trigger *trigger)
 {
 	enum lttng_event_rule_generate_exclusions_status
 			generate_exclusion_status;
 	struct ust_app_event_notifier_rule *ua_event_notifier_rule;
+	struct lttng_condition *condition = NULL;
+	const struct lttng_event_rule *event_rule = NULL;
 
 	ua_event_notifier_rule = zmalloc(sizeof(struct ust_app_event_notifier_rule));
 	if (ua_event_notifier_rule == NULL) {
@@ -1232,15 +1247,21 @@ static struct ust_app_event_notifier_rule *alloc_ust_app_event_notifier_rule(
 	}
 
 	ua_event_notifier_rule->enabled = 1;
-	ua_event_notifier_rule->token = token;
-	lttng_ht_node_init_u64(&ua_event_notifier_rule->node, token);
+	ua_event_notifier_rule->token = lttng_trigger_get_tracer_token(trigger);
+	lttng_ht_node_init_u64(&ua_event_notifier_rule->node,
+			ua_event_notifier_rule->token);
 
-	/* Get reference of the event rule. */
-	if (!lttng_event_rule_get(event_rule)) {
-		abort();
-	}
+	condition = lttng_trigger_get_condition(trigger);
+	assert(condition);
+	assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT);
 
-	ua_event_notifier_rule->event_rule = event_rule;
+	assert(LTTNG_CONDITION_STATUS_OK == lttng_condition_on_event_get_rule(condition, &event_rule));
+	assert(event_rule);
+
+	/* Acquire the event notifier's reference to the trigger. */
+	lttng_trigger_get(trigger);
+
+	ua_event_notifier_rule->trigger = trigger;
 	ua_event_notifier_rule->filter = lttng_event_rule_get_filter_bytecode(event_rule);
 	generate_exclusion_status = lttng_event_rule_generate_exclusions(
 			event_rule, &ua_event_notifier_rule->exclusion);
@@ -1250,8 +1271,8 @@ static struct ust_app_event_notifier_rule *alloc_ust_app_event_notifier_rule(
 		break;
 	default:
 		/* Error occured. */
-		ERR("Failed to generate exclusions from event rule while allocating an event notifier rule");
-		goto error_put_event_rule;
+		ERR("Failed to generate exclusions from trigger while allocating an event notifier rule");
+		goto error_put_trigger;
 	}
 
 	DBG3("UST app event notifier rule allocated: token = %" PRIu64,
@@ -1259,8 +1280,8 @@ static struct ust_app_event_notifier_rule *alloc_ust_app_event_notifier_rule(
 
 	return ua_event_notifier_rule;
 
-error_put_event_rule:
-	lttng_event_rule_put(event_rule);
+error_put_trigger:
+	lttng_trigger_put(trigger);
 error:
 	free(ua_event_notifier_rule);
 	return NULL;
@@ -1283,7 +1304,7 @@ struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context_attr *uctx)
 
 	if (uctx) {
 		memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
-		if (uctx->ctx == LTTNG_UST_CONTEXT_APP_CONTEXT) {
+		if (uctx->ctx == LTTNG_UST_ABI_CONTEXT_APP_CONTEXT) {
 			char *provider_name = NULL, *ctx_name = NULL;
 
 			provider_name = strdup(uctx->u.app_ctx.provider_name);
@@ -1307,50 +1328,51 @@ error:
 }
 
 /*
- * Allocate a filter and copy the given original filter.
+ * Create a liblttng-ust filter bytecode from given bytecode.
  *
  * Return allocated filter or NULL on error.
  */
-static struct lttng_filter_bytecode *copy_filter_bytecode(
-		struct lttng_filter_bytecode *orig_f)
+static struct lttng_ust_abi_filter_bytecode *create_ust_filter_bytecode_from_bytecode(
+		const struct lttng_bytecode *orig_f)
 {
-	struct lttng_filter_bytecode *filter = NULL;
+	struct lttng_ust_abi_filter_bytecode *filter = NULL;
 
-	/* Copy filter bytecode */
+	/* Copy filter bytecode. */
 	filter = zmalloc(sizeof(*filter) + orig_f->len);
 	if (!filter) {
-		PERROR("zmalloc alloc filter bytecode");
+		PERROR("Failed to allocate lttng_ust_filter_bytecode: bytecode len = %" PRIu32 " bytes", orig_f->len);
 		goto error;
 	}
 
+	assert(sizeof(struct lttng_bytecode) ==
+			sizeof(struct lttng_ust_abi_filter_bytecode));
 	memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
-
 error:
 	return filter;
 }
 
 /*
- * Create a liblttng-ust filter bytecode from given bytecode.
+ * Create a liblttng-ust capture bytecode from given bytecode.
  *
  * Return allocated filter or NULL on error.
  */
-static struct lttng_ust_filter_bytecode *create_ust_bytecode_from_bytecode(
-		const struct lttng_filter_bytecode *orig_f)
+static struct lttng_ust_abi_capture_bytecode *
+create_ust_capture_bytecode_from_bytecode(const struct lttng_bytecode *orig_f)
 {
-	struct lttng_ust_filter_bytecode *filter = NULL;
+	struct lttng_ust_abi_capture_bytecode *capture = NULL;
 
-	/* Copy filter bytecode */
-	filter = zmalloc(sizeof(*filter) + orig_f->len);
-	if (!filter) {
-		PERROR("zmalloc alloc ust filter bytecode");
+	/* Copy capture bytecode. */
+	capture = zmalloc(sizeof(*capture) + orig_f->len);
+	if (!capture) {
+		PERROR("Failed to allocate lttng_ust_abi_capture_bytecode: bytecode len = %" PRIu32 " bytes", orig_f->len);
 		goto error;
 	}
 
-	assert(sizeof(struct lttng_filter_bytecode) ==
-			sizeof(struct lttng_ust_filter_bytecode));
-	memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
+	assert(sizeof(struct lttng_bytecode) ==
+			sizeof(struct lttng_ust_abi_capture_bytecode));
+	memcpy(capture, orig_f, sizeof(*capture) + orig_f->len);
 error:
-	return filter;
+	return capture;
 }
 
 /*
@@ -1405,7 +1427,7 @@ error:
  * Return an ust_app_event object or NULL on error.
  */
 static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
-		const char *name, const struct lttng_filter_bytecode *filter,
+		const char *name, const struct lttng_bytecode *filter,
 		int loglevel_value,
 		const struct lttng_event_exclusion *exclusion)
 {
@@ -1514,15 +1536,15 @@ error:
  * Set the filter on the tracer.
  */
 static int set_ust_object_filter(struct ust_app *app,
-		const struct lttng_filter_bytecode *bytecode,
-		struct lttng_ust_object_data *ust_object)
+		const struct lttng_bytecode *bytecode,
+		struct lttng_ust_abi_object_data *ust_object)
 {
 	int ret;
-	struct lttng_ust_filter_bytecode *ust_bytecode = NULL;
+	struct lttng_ust_abi_filter_bytecode *ust_bytecode = NULL;
 
 	health_code_update();
 
-	ust_bytecode = create_ust_bytecode_from_bytecode(bytecode);
+	ust_bytecode = create_ust_filter_bytecode_from_bytecode(bytecode);
 	if (!ust_bytecode) {
 		ret = -LTTNG_ERR_NOMEM;
 		goto error;
@@ -1533,8 +1555,8 @@ static int set_ust_object_filter(struct ust_app *app,
 	pthread_mutex_unlock(&app->sock_lock);
 	if (ret < 0) {
 		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
-			ERR("UST app set object filter failed for object %p of app (pid: %d) "
-					"with ret %d", ust_object, app->pid, ret);
+			ERR("UST app set object filter failed: object = %p of app pid = %d, ret = %d",
+					ust_object, app->pid, ret);
 		} else {
 			/*
 			 * This is normal behavior, an application can die during the
@@ -1547,7 +1569,62 @@ static int set_ust_object_filter(struct ust_app *app,
 		goto error;
 	}
 
-	DBG2("UST filter successfully set for object %p", ust_object);
+	DBG2("UST filter successfully set: object = %p", ust_object);
+
+error:
+	health_code_update();
+	free(ust_bytecode);
+	return ret;
+}
+
+/*
+ * Set a capture bytecode for the passed object.
+ * The sequence number enforces the ordering at runtime and on reception of
+ * the captured payloads.
+ */
+static int set_ust_capture(struct ust_app *app,
+		const struct lttng_bytecode *bytecode,
+		unsigned int capture_seqnum,
+		struct lttng_ust_abi_object_data *ust_object)
+{
+	int ret;
+	struct lttng_ust_abi_capture_bytecode *ust_bytecode = NULL;
+
+	health_code_update();
+
+	ust_bytecode = create_ust_capture_bytecode_from_bytecode(bytecode);
+	if (!ust_bytecode) {
+		ret = -LTTNG_ERR_NOMEM;
+		goto error;
+	}
+
+	/*
+	 * Set the sequence number to ensure the capture of fields is ordered.
+	 */
+	ust_bytecode->seqnum = capture_seqnum;
+
+	pthread_mutex_lock(&app->sock_lock);
+	ret = ustctl_set_capture(app->sock, ust_bytecode,
+			ust_object);
+	pthread_mutex_unlock(&app->sock_lock);
+	if (ret < 0) {
+		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
+			ERR("UST app set object capture failed: object = %p of app pid = %d, ret = %d",
+					ust_object, app->pid, ret);
+		} else {
+			/*
+			 * This is normal behavior, an application can die during the
+			 * creation process. Don't report an error so the execution can
+			 * continue normally.
+			 */
+			ret = 0;
+			DBG3("Failed to set UST app object capture. Application is dead.");
+		}
+
+		goto error;
+	}
+
+	DBG2("UST capture successfully set: object = %p", ust_object);
 
 error:
 	health_code_update();
@@ -1556,12 +1633,12 @@ error:
 }
 
 static
-struct lttng_ust_event_exclusion *create_ust_exclusion_from_exclusion(
+struct lttng_ust_abi_event_exclusion *create_ust_exclusion_from_exclusion(
 		const struct lttng_event_exclusion *exclusion)
 {
-	struct lttng_ust_event_exclusion *ust_exclusion = NULL;
-	size_t exclusion_alloc_size = sizeof(struct lttng_ust_event_exclusion) +
-		LTTNG_UST_SYM_NAME_LEN * exclusion->count;
+	struct lttng_ust_abi_event_exclusion *ust_exclusion = NULL;
+	size_t exclusion_alloc_size = sizeof(struct lttng_ust_abi_event_exclusion) +
+		LTTNG_UST_ABI_SYM_NAME_LEN * exclusion->count;
 
 	ust_exclusion = zmalloc(exclusion_alloc_size);
 	if (!ust_exclusion) {
@@ -1570,7 +1647,7 @@ struct lttng_ust_event_exclusion *create_ust_exclusion_from_exclusion(
 	}
 
 	assert(sizeof(struct lttng_event_exclusion) ==
-			sizeof(struct lttng_ust_event_exclusion));
+			sizeof(struct lttng_ust_abi_event_exclusion));
 	memcpy(ust_exclusion, exclusion, exclusion_alloc_size);
 end:
 	return ust_exclusion;
@@ -1581,10 +1658,10 @@ end:
  */
 static int set_ust_object_exclusions(struct ust_app *app,
 		const struct lttng_event_exclusion *exclusions,
-		struct lttng_ust_object_data *ust_object)
+		struct lttng_ust_abi_object_data *ust_object)
 {
 	int ret;
-	struct lttng_ust_event_exclusion *ust_exclusions = NULL;
+	struct lttng_ust_abi_event_exclusion *ust_exclusions = NULL;
 
 	assert(exclusions && exclusions->count > 0);
 
@@ -1627,7 +1704,7 @@ error:
  * Disable the specified event on to UST tracer for the UST session.
  */
 static int disable_ust_object(struct ust_app *app,
-		struct lttng_ust_object_data *object)
+		struct lttng_ust_abi_object_data *object)
 {
 	int ret;
 
@@ -1742,7 +1819,7 @@ error:
  * Enable the specified event on to UST tracer for the UST session.
  */
 static int enable_ust_object(
-		struct ust_app *app, struct lttng_ust_object_data *ust_object)
+		struct ust_app *app, struct lttng_ust_abi_object_data *ust_object)
 {
 	int ret;
 
@@ -1920,11 +1997,10 @@ error:
 
 static int init_ust_event_notifier_from_event_rule(
 		const struct lttng_event_rule *rule,
-		struct lttng_ust_event_notifier *event_notifier)
+		struct lttng_ust_abi_event_notifier *event_notifier)
 {
 	enum lttng_event_rule_status status;
-	enum lttng_loglevel_type loglevel_type;
-	enum lttng_ust_loglevel_type ust_loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
+	enum lttng_ust_abi_loglevel_type ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
 	int loglevel = -1, ret = 0;
 	const char *pattern;
 
@@ -1934,43 +2010,58 @@ static int init_ust_event_notifier_from_event_rule(
 
 	memset(event_notifier, 0, sizeof(*event_notifier));
 
-	status = lttng_event_rule_tracepoint_get_pattern(rule, &pattern);
-	if (status != LTTNG_EVENT_RULE_STATUS_OK) {
-		/* At this point, this is a fatal error. */
-		abort();
-	}
+	if (lttng_event_rule_targets_agent_domain(rule)) {
+		/*
+		 * Special event for agents
+		 * The actual meat of the event is in the filter that will be
+		 * attached later on.
+		 * Set the default values for the agent event.
+		 */
+		pattern = event_get_default_agent_ust_name(
+				lttng_event_rule_get_domain_type(rule));
+		loglevel = 0;
+		ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
+	} else {
+		const struct lttng_log_level_rule *log_level_rule;
 
-	status = lttng_event_rule_tracepoint_get_log_level_type(
-			rule, &loglevel_type);
-	if (status != LTTNG_EVENT_RULE_STATUS_OK) {
-		/* At this point, this is a fatal error. */
-		abort();
-	}
+		status = lttng_event_rule_tracepoint_get_pattern(rule, &pattern);
+		if (status != LTTNG_EVENT_RULE_STATUS_OK) {
+			/* At this point, this is a fatal error. */
+			abort();
+		}
 
-	switch (loglevel_type) {
-	case LTTNG_EVENT_LOGLEVEL_ALL:
-		ust_loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
-		break;
-	case LTTNG_EVENT_LOGLEVEL_RANGE:
-		ust_loglevel_type = LTTNG_UST_LOGLEVEL_RANGE;
-		break;
-	case LTTNG_EVENT_LOGLEVEL_SINGLE:
-		ust_loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE;
-		break;
-	default:
-		/* Unknown log level specification type. */
-		abort();
-	}
+		status = lttng_event_rule_tracepoint_get_log_level_rule(
+				rule, &log_level_rule);
+		if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
+			ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
+		} else if (status == LTTNG_EVENT_RULE_STATUS_OK) {
+			enum lttng_log_level_rule_status llr_status;
 
-	if (loglevel_type != LTTNG_EVENT_LOGLEVEL_ALL) {
-		status = lttng_event_rule_tracepoint_get_log_level(
-				rule, &loglevel);
-		assert(status == LTTNG_EVENT_RULE_STATUS_OK);
+			switch (lttng_log_level_rule_get_type(log_level_rule)) {
+			case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
+				ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_SINGLE;
+				llr_status = lttng_log_level_rule_exactly_get_level(
+						log_level_rule, &loglevel);
+				break;
+			case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
+				ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_RANGE;
+				llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
+						log_level_rule, &loglevel);
+				break;
+			default:
+				abort();
+			}
+
+			assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
+		} else {
+			/* At this point this is a fatal error. */
+			abort();
+		}
 	}
 
-	event_notifier->event.instrumentation = LTTNG_UST_TRACEPOINT;
+	event_notifier->event.instrumentation = LTTNG_UST_ABI_TRACEPOINT;
 	ret = lttng_strncpy(event_notifier->event.name, pattern,
-			    LTTNG_UST_SYM_NAME_LEN - 1);
+			LTTNG_UST_ABI_SYM_NAME_LEN - 1);
 	if (ret) {
 		ERR("Failed to copy event rule pattern to notifier: pattern = '%s' ",
 				pattern);
@@ -1991,19 +2082,29 @@ static int create_ust_event_notifier(struct ust_app *app,
 		struct ust_app_event_notifier_rule *ua_event_notifier_rule)
 {
 	int ret = 0;
-	struct lttng_ust_event_notifier event_notifier;
+	enum lttng_condition_status condition_status;
+	const struct lttng_condition *condition = NULL;
+	struct lttng_ust_abi_event_notifier event_notifier;
+	const struct lttng_event_rule *event_rule = NULL;
+	unsigned int capture_bytecode_count = 0, i;
+	enum lttng_condition_status cond_status;
 
 	health_code_update();
 	assert(app->event_notifier_group.object);
 
-	ret = init_ust_event_notifier_from_event_rule(
-			ua_event_notifier_rule->event_rule, &event_notifier);
-	if (ret) {
-		ERR("Failed to initialize UST event notifier from event rule: app = '%s' (ppid: %d)",
-				app->name, app->ppid);
-		goto error;
-	}
+	condition = lttng_trigger_get_const_condition(
+			ua_event_notifier_rule->trigger);
+	assert(condition);
+	assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT);
+
+	condition_status = lttng_condition_on_event_get_rule(
+			condition, &event_rule);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
 
+	assert(event_rule);
+	assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
+
+	init_ust_event_notifier_from_event_rule(event_rule, &event_notifier);
 	event_notifier.event.token = ua_event_notifier_rule->token;
 
 	/* Create UST event notifier against the tracer. */
@@ -2058,6 +2159,23 @@ static int create_ust_event_notifier(struct ust_app *app,
 		}
 	}
 
+	/* Set the capture bytecodes. */
+	cond_status = lttng_condition_on_event_get_capture_descriptor_count(
+			condition, &capture_bytecode_count);
+	assert(cond_status == LTTNG_CONDITION_STATUS_OK);
+
+	for (i = 0; i < capture_bytecode_count; i++) {
+		const struct lttng_bytecode *capture_bytecode =
+				lttng_condition_on_event_get_capture_bytecode_at_index(
+						condition, i);
+
+		ret = set_ust_capture(app, capture_bytecode, i,
+				ua_event_notifier_rule->obj);
+		if (ret < 0) {
+			goto error;
+		}
+	}
+
 	/*
 	 * We now need to explicitly enable the event, since it
 	 * is disabled at creation.
@@ -2109,14 +2227,14 @@ static void shadow_copy_event(struct ust_app_event *ua_event,
 
 	/* Copy filter bytecode */
 	if (uevent->filter) {
-		ua_event->filter = copy_filter_bytecode(uevent->filter);
+		ua_event->filter = lttng_bytecode_copy(uevent->filter);
 		/* Filter might be NULL here in case of ENONEM. */
 	}
 
 	/* Copy exclusion data */
 	if (uevent->exclusion) {
 		exclusion_alloc_size = sizeof(struct lttng_event_exclusion) +
-				LTTNG_UST_SYM_NAME_LEN * uevent->exclusion->count;
+				LTTNG_UST_ABI_SYM_NAME_LEN * uevent->exclusion->count;
 		ua_event->exclusion = zmalloc(exclusion_alloc_size);
 		if (ua_event->exclusion == NULL) {
 			PERROR("malloc");
@@ -2566,14 +2684,14 @@ static int ht_match_ust_app_ctx(struct cds_lfht_node *node, const void *_key)
 	}
 
 	switch(key->ctx) {
-	case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
+	case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER:
 		if (strncmp(key->u.perf_counter.name,
 				ctx->ctx.u.perf_counter.name,
 				sizeof(key->u.perf_counter.name))) {
 			goto no_match;
 		}
 		break;
-	case LTTNG_UST_CONTEXT_APP_CONTEXT:
+	case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT:
 		if (strcmp(key->u.app_ctx.provider_name,
 				ctx->ctx.u.app_ctx.provider_name) ||
 				strcmp(key->u.app_ctx.ctx_name,
@@ -2895,12 +3013,12 @@ error:
  *
  * Return 0 on success or else a negative value.
  */
-static int duplicate_channel_object(struct buffer_reg_channel *reg_chan,
+static int duplicate_channel_object(struct buffer_reg_channel *buf_reg_chan,
 		struct ust_app_channel *ua_chan)
 {
 	int ret;
 
-	assert(reg_chan);
+	assert(buf_reg_chan);
 	assert(ua_chan);
 
 	/* Need two fds for the channel. */
@@ -2911,10 +3029,10 @@ static int duplicate_channel_object(struct buffer_reg_channel *reg_chan,
 	}
 
 	/* Duplicate object for stream once the original is in the registry. */
-	ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, reg_chan->obj.ust);
+	ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, buf_reg_chan->obj.ust);
 	if (ret < 0) {
 		ERR("Duplicate channel obj from %p to %p failed with ret: %d",
-				reg_chan->obj.ust, ua_chan->obj, ret);
+				buf_reg_chan->obj.ust, ua_chan->obj, ret);
 		goto error;
 	}
 	ua_chan->handle = ua_chan->obj->handle;
@@ -2933,14 +3051,14 @@ error_fd_get:
  *
  * Return 0 on success or else a negative value.
  */
-static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan,
+static int setup_buffer_reg_streams(struct buffer_reg_channel *buf_reg_chan,
 		struct ust_app_channel *ua_chan,
 		struct ust_app *app)
 {
 	int ret = 0;
 	struct ust_app_stream *stream, *stmp;
 
-	assert(reg_chan);
+	assert(buf_reg_chan);
 	assert(ua_chan);
 
 	DBG2("UST app setup buffer registry stream");
@@ -2960,7 +3078,7 @@ static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan,
 		 */
 		reg_stream->obj.ust = stream->obj;
 		stream->obj = NULL;
-		buffer_reg_stream_add(reg_stream, reg_chan);
+		buffer_reg_stream_add(reg_stream, buf_reg_chan);
 
 		/* We don't need the streams anymore. */
 		cds_list_del(&stream->list);
@@ -2983,7 +3101,7 @@ static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
 		struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp)
 {
 	int ret;
-	struct buffer_reg_channel *reg_chan = NULL;
+	struct buffer_reg_channel *buf_reg_chan = NULL;
 
 	assert(reg_sess);
 	assert(ua_chan);
@@ -2991,14 +3109,14 @@ static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
 	DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
 
 	/* Create buffer registry channel. */
-	ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &reg_chan);
+	ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &buf_reg_chan);
 	if (ret < 0) {
 		goto error_create;
 	}
-	assert(reg_chan);
-	reg_chan->consumer_key = ua_chan->key;
-	reg_chan->subbuf_size = ua_chan->attr.subbuf_size;
-	reg_chan->num_subbuf = ua_chan->attr.num_subbuf;
+	assert(buf_reg_chan);
+	buf_reg_chan->consumer_key = ua_chan->key;
+	buf_reg_chan->subbuf_size = ua_chan->attr.subbuf_size;
+	buf_reg_chan->num_subbuf = ua_chan->attr.num_subbuf;
 
 	/* Create and add a channel registry to session. */
 	ret = ust_registry_channel_add(reg_sess->reg.ust,
@@ -3006,17 +3124,17 @@ static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
 	if (ret < 0) {
 		goto error;
 	}
-	buffer_reg_channel_add(reg_sess, reg_chan);
+	buffer_reg_channel_add(reg_sess, buf_reg_chan);
 
 	if (regp) {
-		*regp = reg_chan;
+		*regp = buf_reg_chan;
 	}
 
 	return 0;
 
 error:
 	/* Safe because the registry channel object was not added to any HT. */
-	buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
+	buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST);
 error_create:
 	return ret;
 }
@@ -3028,32 +3146,32 @@ error_create:
  * Return 0 on success else a negative value.
  */
 static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess,
-		struct ust_app_channel *ua_chan, struct buffer_reg_channel *reg_chan,
+		struct ust_app_channel *ua_chan, struct buffer_reg_channel *buf_reg_chan,
 		struct ust_app *app)
 {
 	int ret;
 
 	assert(reg_sess);
-	assert(reg_chan);
+	assert(buf_reg_chan);
 	assert(ua_chan);
 	assert(ua_chan->obj);
 
 	DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
 
 	/* Setup all streams for the registry. */
-	ret = setup_buffer_reg_streams(reg_chan, ua_chan, app);
+	ret = setup_buffer_reg_streams(buf_reg_chan, ua_chan, app);
 	if (ret < 0) {
 		goto error;
 	}
 
-	reg_chan->obj.ust = ua_chan->obj;
+	buf_reg_chan->obj.ust = ua_chan->obj;
 	ua_chan->obj = NULL;
 
 	return 0;
 
 error:
-	buffer_reg_channel_remove(reg_sess, reg_chan);
-	buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
+	buffer_reg_channel_remove(reg_sess, buf_reg_chan);
+	buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST);
 	return ret;
 }
 
@@ -3062,21 +3180,21 @@ error:
  *
  * Return 0 on success else a negative value.
  */
-static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
+static int send_channel_uid_to_ust(struct buffer_reg_channel *buf_reg_chan,
 		struct ust_app *app, struct ust_app_session *ua_sess,
 		struct ust_app_channel *ua_chan)
 {
 	int ret;
 	struct buffer_reg_stream *reg_stream;
 
-	assert(reg_chan);
+	assert(buf_reg_chan);
 	assert(app);
 	assert(ua_sess);
 	assert(ua_chan);
 
 	DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
 
-	ret = duplicate_channel_object(reg_chan, ua_chan);
+	ret = duplicate_channel_object(buf_reg_chan, ua_chan);
 	if (ret < 0) {
 		goto error;
 	}
@@ -3093,8 +3211,8 @@ static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
 	health_code_update();
 
 	/* Send all streams to application. */
-	pthread_mutex_lock(&reg_chan->stream_list_lock);
-	cds_list_for_each_entry(reg_stream, &reg_chan->streams, lnode) {
+	pthread_mutex_lock(&buf_reg_chan->stream_list_lock);
+	cds_list_for_each_entry(reg_stream, &buf_reg_chan->streams, lnode) {
 		struct ust_app_stream stream;
 
 		ret = duplicate_stream_object(reg_stream, &stream);
@@ -3120,7 +3238,7 @@ static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
 	ua_chan->is_sent = 1;
 
 error_stream_unlock:
-	pthread_mutex_unlock(&reg_chan->stream_list_lock);
+	pthread_mutex_unlock(&buf_reg_chan->stream_list_lock);
 error:
 	return ret;
 }
@@ -3139,10 +3257,10 @@ static int create_channel_per_uid(struct ust_app *app,
 {
 	int ret;
 	struct buffer_reg_uid *reg_uid;
-	struct buffer_reg_channel *reg_chan;
+	struct buffer_reg_channel *buf_reg_chan;
 	struct ltt_session *session = NULL;
 	enum lttng_error_code notification_ret;
-	struct ust_registry_channel *chan_reg;
+	struct ust_registry_channel *ust_reg_chan;
 
 	assert(app);
 	assert(usess);
@@ -3159,14 +3277,14 @@ static int create_channel_per_uid(struct ust_app *app,
 	 */
 	assert(reg_uid);
 
-	reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
+	buf_reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
 			reg_uid);
-	if (reg_chan) {
+	if (buf_reg_chan) {
 		goto send_channel;
 	}
 
 	/* Create the buffer registry channel object. */
-	ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &reg_chan);
+	ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &buf_reg_chan);
 	if (ret < 0) {
 		ERR("Error creating the UST channel \"%s\" registry instance",
 				ua_chan->name);
@@ -3195,8 +3313,8 @@ static int create_channel_per_uid(struct ust_app *app,
 		 */
 		ust_registry_channel_del_free(reg_uid->registry->reg.ust,
 				ua_chan->tracing_channel_id, false);
-		buffer_reg_channel_remove(reg_uid->registry, reg_chan);
-		buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
+		buffer_reg_channel_remove(reg_uid->registry, buf_reg_chan);
+		buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST);
 		goto error;
 	}
 
@@ -3204,7 +3322,7 @@ static int create_channel_per_uid(struct ust_app *app,
 	 * Setup the streams and add it to the session registry.
 	 */
 	ret = setup_buffer_reg_channel(reg_uid->registry,
-			ua_chan, reg_chan, app);
+			ua_chan, buf_reg_chan, app);
 	if (ret < 0) {
 		ERR("Error setting up UST channel \"%s\"", ua_chan->name);
 		goto error;
@@ -3212,11 +3330,11 @@ static int create_channel_per_uid(struct ust_app *app,
 
 	/* Notify the notification subsystem of the channel's creation. */
 	pthread_mutex_lock(&reg_uid->registry->reg.ust->lock);
-	chan_reg = ust_registry_channel_find(reg_uid->registry->reg.ust,
+	ust_reg_chan = ust_registry_channel_find(reg_uid->registry->reg.ust,
 			ua_chan->tracing_channel_id);
-	assert(chan_reg);
-	chan_reg->consumer_key = ua_chan->key;
-	chan_reg = NULL;
+	assert(ust_reg_chan);
+	ust_reg_chan->consumer_key = ua_chan->key;
+	ust_reg_chan = NULL;
 	pthread_mutex_unlock(&reg_uid->registry->reg.ust->lock);
 
 	notification_ret = notification_thread_command_add_channel(
@@ -3234,7 +3352,7 @@ static int create_channel_per_uid(struct ust_app *app,
 
 send_channel:
 	/* Send buffers to the application. */
-	ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan);
+	ret = send_channel_uid_to_ust(buf_reg_chan, app, ua_sess, ua_chan);
 	if (ret < 0) {
 		if (ret != -ENOTCONN) {
 			ERR("Error sending channel to application");
@@ -3266,7 +3384,7 @@ static int create_channel_per_pid(struct ust_app *app,
 	enum lttng_error_code cmd_ret;
 	struct ltt_session *session = NULL;
 	uint64_t chan_reg_key;
-	struct ust_registry_channel *chan_reg;
+	struct ust_registry_channel *ust_reg_chan;
 
 	assert(app);
 	assert(usess);
@@ -3315,9 +3433,9 @@ static int create_channel_per_pid(struct ust_app *app,
 
 	chan_reg_key = ua_chan->key;
 	pthread_mutex_lock(&registry->lock);
-	chan_reg = ust_registry_channel_find(registry, chan_reg_key);
-	assert(chan_reg);
-	chan_reg->consumer_key = ua_chan->key;
+	ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key);
+	assert(ust_reg_chan);
+	ust_reg_chan->consumer_key = ua_chan->key;
 	pthread_mutex_unlock(&registry->lock);
 
 	cmd_ret = notification_thread_command_add_channel(
@@ -3416,7 +3534,7 @@ error:
  */
 static int ust_app_channel_allocate(struct ust_app_session *ua_sess,
 		struct ltt_ust_channel *uchan,
-		enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
+		enum lttng_ust_abi_chan_type type, struct ltt_ust_session *usess,
 		struct ust_app_channel **ua_chanp)
 {
 	int ret = 0;
@@ -3519,13 +3637,13 @@ error:
  * Called with ust app session mutex held.
  */
 static
-int create_ust_app_event_notifier_rule(struct lttng_event_rule *rule,
-		struct ust_app *app, uint64_t token)
+int create_ust_app_event_notifier_rule(struct lttng_trigger *trigger,
+		struct ust_app *app)
 {
 	int ret = 0;
 	struct ust_app_event_notifier_rule *ua_event_notifier_rule;
 
-	ua_event_notifier_rule = alloc_ust_app_event_notifier_rule(rule, token);
+	ua_event_notifier_rule = alloc_ust_app_event_notifier_rule(trigger);
 	if (ua_event_notifier_rule == NULL) {
 		ret = -ENOMEM;
 		goto end;
@@ -3543,7 +3661,7 @@ int create_ust_app_event_notifier_rule(struct lttng_event_rule *rule,
 		if (ret == -LTTNG_UST_ERR_EXIST) {
 			ERR("Tracer for application reported that an event notifier being created already exists: "
 					"token = \"%" PRIu64 "\", pid = %d, ppid = %d, uid = %d, gid = %d",
-					token,
+					lttng_trigger_get_tracer_token(trigger),
 					app->pid, app->ppid, app->uid,
 					app->gid);
 		}
@@ -3554,7 +3672,7 @@ int create_ust_app_event_notifier_rule(struct lttng_event_rule *rule,
 			&ua_event_notifier_rule->node);
 
 	DBG2("UST app create token event rule completed: app = '%s' (ppid: %d), token = %" PRIu64,
-			app->name, app->ppid, token);
+			app->name, app->ppid, lttng_trigger_get_tracer_token(trigger));
 
 end:
 	return ret;
@@ -3708,6 +3826,7 @@ error:
  */
 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
 {
+	int ret;
 	struct ust_app *lta = NULL;
 	struct lttng_pipe *event_notifier_event_source_pipe = NULL;
 
@@ -3726,6 +3845,18 @@ struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
 		goto error;
 	}
 
+	/*
+	 * Reserve the two file descriptors of the event source pipe. The write
+	 * end will be closed once it is passed to the application, at which
+	 * point a single 'put' will be performed.
+	 */
+	ret = lttng_fd_get(LTTNG_FD_APPS, 2);
+	if (ret) {
+		ERR("Failed to reserve two file descriptors for the event source pipe while creating a new application instance: app = '%s' (ppid: %d)",
+				msg->name, (int) msg->ppid);
+		goto error;
+	}
+
 	event_notifier_event_source_pipe = lttng_pipe_open(FD_CLOEXEC);
 	if (!event_notifier_event_source_pipe) {
 		PERROR("Failed to open application event source pipe: '%s' (ppid = %d)",
@@ -3783,6 +3914,7 @@ struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
 
 error_free_pipe:
 	lttng_pipe_destroy(event_notifier_event_source_pipe);
+	lttng_fd_put(LTTNG_FD_APPS, 2);
 error:
 	return NULL;
 }
@@ -3860,7 +3992,7 @@ int ust_app_setup_event_notifier_group(struct ust_app *app)
 {
 	int ret;
 	int event_pipe_write_fd;
-	struct lttng_ust_object_data *event_notifier_group = NULL;
+	struct lttng_ust_abi_object_data *event_notifier_group = NULL;
 	enum lttng_error_code lttng_ret;
 
 	assert(app);
@@ -3892,6 +4024,12 @@ int ust_app_setup_event_notifier_group(struct ust_app *app)
 		goto error;
 	}
 
+	/*
+	 * Release the file descriptor that was reserved for the write-end of
+	 * the pipe.
+	 */
+	lttng_fd_put(LTTNG_FD_APPS, 1);
+
 	lttng_ret = notification_thread_command_add_tracer_event_source(
 			notification_thread_handle,
 			lttng_pipe_get_readfd(app->event_notifier_group.event_pipe),
@@ -4054,7 +4192,7 @@ int ust_app_list_events(struct lttng_event **events)
 	rcu_read_lock();
 
 	cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
-		struct lttng_ust_tracepoint_iter uiter;
+		struct lttng_ust_abi_tracepoint_iter uiter;
 
 		health_code_update();
 
@@ -4137,9 +4275,9 @@ int ust_app_list_events(struct lttng_event **events)
 				nbmem = new_nbmem;
 				tmp_event = new_tmp_event;
 			}
-			memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
+			memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_ABI_SYM_NAME_LEN);
 			tmp_event[count].loglevel = uiter.loglevel;
-			tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
+			tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_ABI_TRACEPOINT;
 			tmp_event[count].pid = app->pid;
 			tmp_event[count].enabled = -1;
 			count++;
@@ -4185,7 +4323,7 @@ int ust_app_list_event_fields(struct lttng_event_field **fields)
 	rcu_read_lock();
 
 	cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
-		struct lttng_ust_field_iter uiter;
+		struct lttng_ust_abi_field_iter uiter;
 
 		health_code_update();
 
@@ -4269,12 +4407,12 @@ int ust_app_list_event_fields(struct lttng_event_field **fields)
 				tmp_event = new_tmp_event;
 			}
 
-			memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
+			memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
 			/* Mapping between these enums matches 1 to 1. */
 			tmp_event[count].type = (enum lttng_event_field_type) uiter.type;
 			tmp_event[count].nowrite = uiter.nowrite;
 
-			memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
+			memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_ABI_SYM_NAME_LEN);
 			tmp_event[count].event.loglevel = uiter.loglevel;
 			tmp_event[count].event.type = LTTNG_EVENT_TRACEPOINT;
 			tmp_event[count].event.pid = app->pid;
@@ -4573,7 +4711,7 @@ int ust_app_channel_create(struct ltt_ust_session *usess,
 		 * configuration.
 		 */
 		ret = ust_app_channel_allocate(ua_sess, uchan,
-			LTTNG_UST_CHAN_PER_CPU, usess,
+			LTTNG_UST_ABI_CHAN_PER_CPU, usess,
 			&ua_chan);
 		if (ret < 0) {
 			goto error;
@@ -5054,7 +5192,7 @@ int ust_app_flush_session(struct ltt_ust_session *usess)
 		/* Flush all per UID buffers associated to that session. */
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
 			struct ust_registry_session *ust_session_reg;
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 			struct consumer_socket *socket;
 
 			/* Get consumer socket to use to push the metadata.*/
@@ -5066,13 +5204,13 @@ int ust_app_flush_session(struct ltt_ust_session *usess)
 			}
 
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
-					reg_chan, node.node) {
+					buf_reg_chan, node.node) {
 				/*
 				 * The following call will print error values so the return
 				 * code is of little importance because whatever happens, we
 				 * have to try them all.
 				 */
-				(void) consumer_flush_channel(socket, reg_chan->consumer_key);
+				(void) consumer_flush_channel(socket, buf_reg_chan->consumer_key);
 			}
 
 			ust_session_reg = reg->registry->reg.ust;
@@ -5201,7 +5339,7 @@ int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
 		 */
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
 			struct consumer_socket *socket;
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 
 			/* Get associated consumer socket.*/
 			socket = consumer_find_socket_by_bitness(
@@ -5215,7 +5353,7 @@ int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
 			}
 
 			cds_lfht_for_each_entry(reg->registry->channels->ht,
-					&iter.iter, reg_chan, node.node) {
+					&iter.iter, buf_reg_chan, node.node) {
 				/*
 				 * The following call will print error values so
 				 * the return code is of little importance
@@ -5223,7 +5361,7 @@ int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
 				 * all.
 				 */
 				(void) consumer_clear_quiescent_channel(socket,
-						reg_chan->consumer_key);
+						buf_reg_chan->consumer_key);
 			}
 		}
 		break;
@@ -5512,12 +5650,12 @@ void ust_app_synchronize_event_notifier_rules(struct ust_app *app)
 		token = lttng_trigger_get_tracer_token(trigger);
 		condition = lttng_trigger_get_condition(trigger);
 
-		if (lttng_condition_get_type(condition) != LTTNG_CONDITION_TYPE_EVENT_RULE_HIT) {
+		if (lttng_condition_get_type(condition) != LTTNG_CONDITION_TYPE_ON_EVENT) {
 			/* Does not apply */
 			continue;
 		}
 
-		condition_status = lttng_condition_event_rule_borrow_rule_mutable(condition, &event_rule);
+		condition_status = lttng_condition_on_event_borrow_rule_mutable(condition, &event_rule);
 		assert(condition_status == LTTNG_CONDITION_STATUS_OK);
 
 		if (lttng_event_rule_get_domain_type(event_rule) == LTTNG_DOMAIN_KERNEL) {
@@ -5533,7 +5671,7 @@ void ust_app_synchronize_event_notifier_rules(struct ust_app *app)
 		looked_up_event_notifier_rule = find_ust_app_event_notifier_rule(
 				app->token_to_event_notifier_rule_ht, token);
 		if (!looked_up_event_notifier_rule) {
-			ret = create_ust_app_event_notifier_rule(event_rule, app, token);
+			ret = create_ust_app_event_notifier_rule(trigger, app);
 			if (ret < 0) {
 				goto end;
 			}
@@ -5597,38 +5735,20 @@ end:
 }
 
 /*
- * The caller must ensure that the application is compatible and is tracked
- * by the process attribute trackers.
+ * RCU read lock must be held by the caller.
  */
 static
-void ust_app_synchronize(struct ltt_ust_session *usess,
+void ust_app_synchronize_all_channels(struct ltt_ust_session *usess,
+		struct ust_app_session *ua_sess,
 		struct ust_app *app)
 {
 	int ret = 0;
 	struct cds_lfht_iter uchan_iter;
 	struct ltt_ust_channel *uchan;
-	struct ust_app_session *ua_sess = NULL;
-
-	/*
-	 * The application's configuration should only be synchronized for
-	 * active sessions.
-	 */
-	assert(usess->active);
 
-	ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL);
-	if (ret < 0) {
-		/* Tracer is probably gone or ENOMEM. */
-		goto error;
-	}
+	assert(usess);
 	assert(ua_sess);
-
-	pthread_mutex_lock(&ua_sess->lock);
-	if (ua_sess->deleted) {
-		pthread_mutex_unlock(&ua_sess->lock);
-		goto end;
-	}
-
-	rcu_read_lock();
+	assert(app);
 
 	cds_lfht_for_each_entry(usess->domain_global.channels->ht, &uchan_iter,
 			uchan, node.node) {
@@ -5647,7 +5767,7 @@ void ust_app_synchronize(struct ltt_ust_session *usess,
 			app, uchan, &ua_chan);
 		if (ret) {
 			/* Tracer is probably gone or ENOMEM. */
-			goto error_unlock;
+			goto end;
 		}
 
 		if (!ua_chan) {
@@ -5660,7 +5780,7 @@ void ust_app_synchronize(struct ltt_ust_session *usess,
 			ret = ust_app_channel_synchronize_event(ua_chan,
 				uevent, ua_sess, app);
 			if (ret) {
-				goto error_unlock;
+				goto end;
 			}
 		}
 
@@ -5669,10 +5789,47 @@ void ust_app_synchronize(struct ltt_ust_session *usess,
 				enable_ust_app_channel(ua_sess, uchan, app) :
 				disable_ust_app_channel(ua_sess, ua_chan, app);
 			if (ret) {
-				goto error_unlock;
+				goto end;
 			}
 		}
 	}
+end:
+	return;
+}
+
+/*
+ * The caller must ensure that the application is compatible and is tracked
+ * by the process attribute trackers.
+ */
+static
+void ust_app_synchronize(struct ltt_ust_session *usess,
+		struct ust_app *app)
+{
+	int ret = 0;
+	struct ust_app_session *ua_sess = NULL;
+
+	/*
+	 * The application's configuration should only be synchronized for
+	 * active sessions.
+	 */
+	assert(usess->active);
+
+	ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL);
+	if (ret < 0) {
+		/* Tracer is probably gone or ENOMEM. */
+		goto error;
+	}
+	assert(ua_sess);
+
+	pthread_mutex_lock(&ua_sess->lock);
+	if (ua_sess->deleted) {
+		pthread_mutex_unlock(&ua_sess->lock);
+		goto end;
+	}
+
+	rcu_read_lock();
+
+	ust_app_synchronize_all_channels(usess, ua_sess, app);
 
 	/*
 	 * Create the metadata for the application. This returns gracefully if a
@@ -5983,7 +6140,7 @@ static int reply_ust_register_channel(int sock, int cobjd,
 	struct ust_app_channel *ua_chan;
 	struct ust_app_session *ua_sess;
 	struct ust_registry_session *registry;
-	struct ust_registry_channel *chan_reg;
+	struct ust_registry_channel *ust_reg_chan;
 
 	rcu_read_lock();
 
@@ -6024,30 +6181,30 @@ static int reply_ust_register_channel(int sock, int cobjd,
 
 	pthread_mutex_lock(&registry->lock);
 
-	chan_reg = ust_registry_channel_find(registry, chan_reg_key);
-	assert(chan_reg);
+	ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key);
+	assert(ust_reg_chan);
 
-	if (!chan_reg->register_done) {
+	if (!ust_reg_chan->register_done) {
 		/*
 		 * TODO: eventually use the registry event count for
 		 * this channel to better guess header type for per-pid
 		 * buffers.
 		 */
 		type = USTCTL_CHANNEL_HEADER_LARGE;
-		chan_reg->nr_ctx_fields = nr_fields;
-		chan_reg->ctx_fields = fields;
+		ust_reg_chan->nr_ctx_fields = nr_fields;
+		ust_reg_chan->ctx_fields = fields;
 		fields = NULL;
-		chan_reg->header_type = type;
+		ust_reg_chan->header_type = type;
 	} else {
 		/* Get current already assigned values. */
-		type = chan_reg->header_type;
+		type = ust_reg_chan->header_type;
 	}
 	/* Channel id is set during the object creation. */
-	chan_id = chan_reg->chan_id;
+	chan_id = ust_reg_chan->chan_id;
 
 	/* Append to metadata */
-	if (!chan_reg->metadata_dumped) {
-		ret_code = ust_metadata_channel_statedump(registry, chan_reg);
+	if (!ust_reg_chan->metadata_dumped) {
+		ret_code = ust_metadata_channel_statedump(registry, ust_reg_chan);
 		if (ret_code) {
 			ERR("Error appending channel metadata (errno = %d)", ret_code);
 			goto reply;
@@ -6070,7 +6227,7 @@ reply:
 	}
 
 	/* This channel registry registration is completed. */
-	chan_reg->register_done = 1;
+	ust_reg_chan->register_done = 1;
 
 error:
 	pthread_mutex_unlock(&registry->lock);
@@ -6293,7 +6450,7 @@ int ust_app_recv_notify(int sock)
 	case USTCTL_NOTIFY_CMD_EVENT:
 	{
 		int sobjd, cobjd, loglevel_value;
-		char name[LTTNG_UST_SYM_NAME_LEN], *sig, *model_emf_uri;
+		char name[LTTNG_UST_ABI_SYM_NAME_LEN], *sig, *model_emf_uri;
 		size_t nr_fields;
 		struct ustctl_field *fields;
 
@@ -6360,7 +6517,7 @@ int ust_app_recv_notify(int sock)
 	case USTCTL_NOTIFY_CMD_ENUM:
 	{
 		int sobjd;
-		char name[LTTNG_UST_SYM_NAME_LEN];
+		char name[LTTNG_UST_ABI_SYM_NAME_LEN];
 		size_t nr_entries;
 		struct ustctl_enum_entry *entries;
 
@@ -6512,7 +6669,7 @@ enum lttng_error_code ust_app_snapshot_record(
 		struct buffer_reg_uid *reg;
 
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 			struct consumer_socket *socket;
 			char pathname[PATH_MAX];
 			size_t consumer_path_offset = 0;
@@ -6549,9 +6706,9 @@ enum lttng_error_code ust_app_snapshot_record(
 			}
 			/* Add the UST default trace dir to path. */
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
-					reg_chan, node.node) {
+					buf_reg_chan, node.node) {
 				status = consumer_snapshot_channel(socket,
-						reg_chan->consumer_key,
+						buf_reg_chan->consumer_key,
 						output, 0, usess->uid,
 						usess->gid, &trace_path[consumer_path_offset], wait,
 						nb_packets_per_stream);
@@ -6679,19 +6836,19 @@ uint64_t ust_app_get_size_one_more_packet_per_stream(
 		struct buffer_reg_uid *reg;
 
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 
 			rcu_read_lock();
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
-					reg_chan, node.node) {
-				if (cur_nr_packets >= reg_chan->num_subbuf) {
+					buf_reg_chan, node.node) {
+				if (cur_nr_packets >= buf_reg_chan->num_subbuf) {
 					/*
 					 * Don't take channel into account if we
 					 * already grab all its packets.
 					 */
 					continue;
 				}
-				tot_size += reg_chan->subbuf_size * reg_chan->stream_count;
+				tot_size += buf_reg_chan->subbuf_size * buf_reg_chan->stream_count;
 			}
 			rcu_read_unlock();
 		}
@@ -6915,7 +7072,7 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 		struct buffer_reg_uid *reg;
 
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 			struct consumer_socket *socket;
 
 			if (!reg->registry->reg.ust->metadata_key) {
@@ -6933,9 +7090,9 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 
 			/* Rotate the data channels. */
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
-					reg_chan, node.node) {
+					buf_reg_chan, node.node) {
 				ret = consumer_rotate_channel(socket,
-						reg_chan->consumer_key,
+						buf_reg_chan->consumer_key,
 						usess->uid, usess->gid,
 						usess->consumer,
 						/* is_metadata_channel */ false);
@@ -7172,7 +7329,7 @@ enum lttng_error_code ust_app_clear_session(struct ltt_session *session)
 		struct buffer_reg_uid *reg;
 
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 			struct consumer_socket *socket;
 
 			/* Get consumer socket to use to push the metadata.*/
@@ -7185,9 +7342,9 @@ enum lttng_error_code ust_app_clear_session(struct ltt_session *session)
 
 			/* Clear the data channels. */
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
-					reg_chan, node.node) {
+					buf_reg_chan, node.node) {
 				ret = consumer_clear_channel(socket,
-						reg_chan->consumer_key);
+						buf_reg_chan->consumer_key);
 				if (ret < 0) {
 					goto error;
 				}
@@ -7324,7 +7481,7 @@ enum lttng_error_code ust_app_open_packets(struct ltt_session *session)
 
 		cds_list_for_each_entry (
 				reg, &usess->buffer_reg_uid_list, lnode) {
-			struct buffer_reg_channel *reg_chan;
+			struct buffer_reg_channel *buf_reg_chan;
 			struct consumer_socket *socket;
 
 			socket = consumer_find_socket_by_bitness(
@@ -7335,11 +7492,11 @@ enum lttng_error_code ust_app_open_packets(struct ltt_session *session)
 			}
 
 			cds_lfht_for_each_entry(reg->registry->channels->ht,
-					&iter.iter, reg_chan, node.node) {
+					&iter.iter, buf_reg_chan, node.node) {
 				const int open_ret =
 						consumer_open_channel_packets(
 							socket,
-							reg_chan->consumer_key);
+							buf_reg_chan->consumer_key);
 
 				if (open_ret < 0) {
 					ret = LTTNG_ERR_UNK;