X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fevent.c;h=dd2e4b382fa46ca76978898a2a0e1b38bd8ccf9c;hp=e4c79df74a4dca37f132478408caacd92d9f2577;hb=refs%2Fheads%2Fsow-2020-0002-rev3;hpb=6b10b3b01eb754c0c3149490f700763dbac60ed5

diff --git a/src/bin/lttng-sessiond/event.c b/src/bin/lttng-sessiond/event.c
index e4c79df74..dd2e4b382 100644
--- a/src/bin/lttng-sessiond/event.c
+++ b/src/bin/lttng-sessiond/event.c
@@ -1,44 +1,45 @@
 /*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, version 2 only,
- * as published by the Free Software Foundation.
+ * SPDX-License-Identifier: GPL-2.0-only
  *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #define _LGPL_SOURCE
-#include <errno.h>
 #include <urcu/list.h>
 #include <string.h>
 
+#include <common/compat/errno.h>
 #include <lttng/lttng.h>
+#include <lttng/condition/condition.h>
+#include <lttng/condition/on-event.h>
+#include <lttng/event-rule/event-rule.h>
+#include <lttng/event-rule/event-rule-internal.h>
+#include <common/bytecode/bytecode.h>
 #include <common/error.h>
 #include <common/sessiond-comm/sessiond-comm.h>
+#include <common/filter.h>
+#include <common/kernel-ctl/kernel-ctl.h>
+#include <common/context.h>
 
 #include "channel.h"
 #include "event.h"
 #include "kernel.h"
 #include "lttng-sessiond.h"
-#include "ust-ctl.h"
+#include "lttng-ust-ctl.h"
+#include "lttng-ust-error.h"
 #include "ust-app.h"
 #include "trace-kernel.h"
 #include "trace-ust.h"
 #include "agent.h"
+#include "utils.h"
 
 /*
  * Add unique UST event based on the event name, filter bytecode and loglevel.
  */
 static void add_unique_ust_event(struct lttng_ht *ht,
-		struct ltt_ust_event *event)
+		struct ltt_ust_event *event, struct lttng_map_key *map_key)
 {
 	struct cds_lfht_node *node_ptr;
 	struct ltt_ust_ht_key key;
@@ -48,10 +49,11 @@ static void add_unique_ust_event(struct lttng_ht *ht,
 	assert(event);
 
 	key.name = event->attr.name;
-	key.filter = (struct lttng_filter_bytecode *) event->filter;
+	key.filter = (struct lttng_bytecode *) event->filter;
 	key.loglevel_type = event->attr.loglevel_type;
 	key.loglevel_value = event->attr.loglevel;
 	key.exclusion = event->exclusion;
+	key.key = map_key;
 
 	node_ptr = cds_lfht_add_unique(ht->ht,
 			ht->hash_fct(event->node.key, lttng_ht_seed),
@@ -66,7 +68,7 @@ static void add_unique_ust_event(struct lttng_ht *ht,
  * If event_name is NULL all events of the specified type are disabled.
  */
 int event_kernel_disable_event(struct ltt_kernel_channel *kchan,
-		char *event_name, enum lttng_event_type type)
+		const char *event_name, enum lttng_event_type type)
 {
 	int ret, error = 0, found = 0;
 	struct ltt_kernel_event *kevent;
@@ -105,7 +107,7 @@ int event_kernel_disable_event(struct ltt_kernel_channel *kchan,
  */
 int event_kernel_enable_event(struct ltt_kernel_channel *kchan,
 		struct lttng_event *event, char *filter_expression,
-		struct lttng_filter_bytecode *filter)
+		struct lttng_bytecode *filter)
 {
 	int ret;
 	struct ltt_kernel_event *kevent;
@@ -113,26 +115,14 @@ int event_kernel_enable_event(struct ltt_kernel_channel *kchan,
 	assert(kchan);
 	assert(event);
 
-	kevent = trace_kernel_find_event(event->name, kchan,
-			event->type, filter);
+	kevent = trace_kernel_find_event(&kchan->events_list,
+			0, event->name, event->type, filter);
 	if (kevent == NULL) {
-		ret = kernel_create_event(event, kchan,
-			filter_expression, filter);
+		ret = kernel_create_event(event, kchan, filter_expression, filter);
 		/* We have passed ownership */
 		filter_expression = NULL;
 		filter = NULL;
-		if (ret < 0) {
-			switch (-ret) {
-			case EEXIST:
-				ret = LTTNG_ERR_KERN_EVENT_EXIST;
-				break;
-			case ENOSYS:
-				ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
-				break;
-			default:
-				ret = LTTNG_ERR_KERN_ENABLE_FAIL;
-				break;
-			}
+		if (ret) {
 			goto end;
 		}
 	} else if (kevent->enabled == 0) {
@@ -154,6 +144,104 @@ end:
 	return ret;
 }
 
+/*
+ * Disable kernel tracepoint events for a map from the kernel session of
+ * a specified event_name and event type.
+ * On type LTTNG_EVENT_ALL all events with event_name are disabled.
+ * If event_name is NULL all events of the specified type are disabled.
+ */
+int map_event_kernel_disable_event(struct ltt_kernel_map *kmap,
+		uint64_t action_tracer_token)
+{
+	struct ltt_kernel_event_counter *kevent_counter;
+	struct lttng_ht_iter iter;
+	const struct lttng_ht_node_u64 *node;
+	enum lttng_error_code ret_code;
+	int ret;
+
+	assert(kmap);
+
+	lttng_ht_lookup(kmap->event_counters_ht, (void *) &action_tracer_token, &iter);
+	node = lttng_ht_iter_get_node_u64(&iter);
+	if (node){
+		kevent_counter = caa_container_of(node,
+				struct ltt_kernel_event_counter, ht_node);
+		ret = kernctl_disable(kevent_counter->fd);
+		if (ret < 0) {
+			ret_code = LTTNG_ERR_KERN_DISABLE_FAIL;
+			goto end;
+		}
+		kevent_counter->enabled = false;
+		DBG("Disable kernel event counter");
+	} else {
+		ret_code = LTTNG_ERR_NO_EVENT;
+		goto end;
+	}
+
+	ret_code = LTTNG_OK;
+end:
+	return ret_code;
+}
+
+/*
+ * Enable kernel tracepoint event for a map from the kernel session.
+ * We own filter_expression and filter.
+ */
+int map_event_kernel_enable_event(struct ltt_kernel_map *kmap,
+		const struct lttng_credentials *creds,
+		uint64_t action_tracer_token,
+		const struct lttng_event_rule *event_rule,
+		struct lttng_map_key *key)
+{
+	int err;
+	enum lttng_error_code ret_code;
+	struct ltt_kernel_event_counter *kevent_counter;
+	struct lttng_ht_iter iter;
+	const struct lttng_ht_node_u64 *node;
+
+	assert(kmap);
+	assert(event_rule);
+	assert(key);
+
+	lttng_ht_lookup(kmap->event_counters_ht, (void *) &action_tracer_token, &iter);
+	node = lttng_ht_iter_get_node_u64(&iter);
+	if (node){
+		kevent_counter = caa_container_of(node,
+				struct ltt_kernel_event_counter, ht_node);
+		if (kevent_counter->enabled) {
+			/* At this point, the event is considered enabled */
+			ret_code = LTTNG_ERR_KERN_EVENT_EXIST;
+			goto end;
+		}
+
+		err = kernctl_enable(kevent_counter->fd);
+		if (err < 0) {
+			switch (-err) {
+			case EEXIST:
+				ret_code = LTTNG_ERR_KERN_EVENT_EXIST;
+				break;
+			default:
+				PERROR("enable kernel event counter");
+				ret_code = LTTNG_ERR_KERN_ENABLE_FAIL;
+				break;
+			}
+			goto end;
+		}
+
+	} else {
+
+		ret_code = kernel_create_event_counter(kmap, creds,
+				action_tracer_token, event_rule, key);
+		if (ret_code != LTTNG_OK) {
+			goto end;
+		}
+	}
+
+	ret_code = LTTNG_OK;
+end:
+	return ret_code;
+}
+
 /*
  * ============================
  * UST : The Ultimate Frontier!
@@ -167,30 +255,38 @@ end:
 int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
 		struct ltt_ust_channel *uchan, struct lttng_event *event,
 		char *filter_expression,
-		struct lttng_filter_bytecode *filter,
+		struct lttng_bytecode *filter,
 		struct lttng_event_exclusion *exclusion,
 		bool internal_event)
 {
 	int ret = LTTNG_OK, to_create = 0;
 	struct ltt_ust_event *uevent;
 
+	/*
+	 * FIXME: Frdeso. The tracer token should probably me set for regular
+	 * events too.
+	 */
+	uint64_t tracer_token = 0;
+
 	assert(usess);
 	assert(uchan);
 	assert(event);
 
 	rcu_read_lock();
 
-	uevent = trace_ust_find_event(uchan->events, event->name, filter,
-			event->loglevel_type, event->loglevel, exclusion);
+	uevent = trace_ust_find_event(uchan->events, 0, event->name, filter,
+			(enum lttng_ust_loglevel_type) event->loglevel_type,
+			event->loglevel, exclusion, NULL);
 	if (!uevent) {
-		uevent = trace_ust_create_event(event, filter_expression,
-				filter, exclusion, internal_event);
+		ret = trace_ust_create_event(tracer_token, event->name, NULL, event->type,
+				event->loglevel_type, event->loglevel,
+				filter_expression, filter, exclusion,
+				internal_event, &uevent);
 		/* We have passed ownership */
 		filter_expression = NULL;
 		filter = NULL;
 		exclusion = NULL;
-		if (uevent == NULL) {
-			ret = LTTNG_ERR_UST_ENABLE_FAIL;
+		if (ret != LTTNG_OK) {
 			goto error;
 		}
 
@@ -200,18 +296,27 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
 
 	if (uevent->enabled) {
 		/* It's already enabled so everything is OK */
+		assert(!to_create);
 		ret = LTTNG_ERR_UST_EVENT_ENABLED;
 		goto end;
 	}
 
 	uevent->enabled = 1;
+	if (to_create) {
+		/* Add ltt ust event to channel */
+		add_unique_ust_event(uchan->events, uevent, NULL);
+	}
+
+	if (!usess->active) {
+		goto end;
+	}
 
 	if (to_create) {
 		/* Create event on all UST registered apps for session */
-		ret = ust_app_create_event_glb(usess, uchan, uevent);
+		ret = ust_app_create_channel_event_glb(usess, uchan, uevent);
 	} else {
 		/* Enable event on all UST registered apps for session */
-		ret = ust_app_enable_event_glb(usess, uchan, uevent);
+		ret = ust_app_enable_channel_event_glb(usess, uchan, uevent);
 	}
 
 	if (ret < 0) {
@@ -224,11 +329,6 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
 		}
 	}
 
-	if (to_create) {
-		/* Add ltt ust event to channel */
-		add_unique_ust_event(uchan->events, uevent);
-	}
-
 	DBG("Event UST %s %s in channel %s", uevent->attr.name,
 			to_create ? "created" : "enabled", uchan->name);
 
@@ -260,11 +360,145 @@ error:
 	return ret;
 }
 
+/*
+ * Enable UST tracepoint event for a map from a UST session.
+ */
+enum lttng_error_code map_event_ust_enable_tracepoint(
+		struct ltt_ust_session *usess,
+		struct ltt_ust_map *umap,
+		uint64_t tracer_token,
+		char *ev_name,
+		struct lttng_map_key *key,
+		enum lttng_event_type ev_type,
+		enum lttng_loglevel_type ev_loglevel_type,
+		int ev_loglevel_value,
+		char *_filter_expression,
+		struct lttng_bytecode *_filter,
+		struct lttng_event_exclusion *exclusion,
+		bool internal_event)
+{
+	enum lttng_error_code ret_code = LTTNG_OK;
+	int ret, to_create = 0;
+	struct ltt_ust_event *uevent;
+	struct lttng_bytecode *filter = NULL;
+	char *filter_expression = NULL;
+
+
+	assert(usess);
+	assert(umap);
+
+	/*
+ 	 * FIXME: FRDESO: this function was copied from ust-app.c
+ 	 */
+ 	if (_filter_expression) {
+		filter_expression = strdup(_filter_expression);
+	}
+
+	if (_filter) {
+		filter = zmalloc(sizeof(*filter) + _filter->len);
+		if (!filter) {
+			PERROR("Failed to allocate lttng_ust_filter_bytecode: bytecode len = %" PRIu32 " bytes", _filter->len);
+			goto error;
+		}
+
+		assert(sizeof(struct lttng_bytecode) ==
+			sizeof(struct lttng_ust_filter_bytecode));
+		memcpy(filter, _filter, sizeof(*filter) + _filter->len);
+	}
+
+	rcu_read_lock();
+
+	uevent = trace_ust_find_event(umap->events, tracer_token, ev_name, filter,
+			(enum lttng_ust_loglevel_type) ev_loglevel_type,
+			ev_loglevel_value, exclusion, key);
+	if (!uevent) {
+		ret_code = trace_ust_create_event(tracer_token, ev_name, key, ev_type,
+				ev_loglevel_type, ev_loglevel_value,
+				filter_expression, filter, exclusion,
+				internal_event, &uevent);
+		/* We have passed ownership */
+		filter_expression = NULL;
+		filter = NULL;
+		exclusion = NULL;
+		if (ret_code != LTTNG_OK) {
+			goto error;
+		}
+
+		/* Valid to set it after the goto error since uevent is still NULL */
+		to_create = 1;
+	}
+
+	if (uevent->enabled) {
+		/* It's already enabled so everything is OK */
+		assert(!to_create);
+		ret_code = LTTNG_ERR_UST_EVENT_ENABLED;
+		goto end;
+	}
+
+	uevent->enabled = 1;
+	if (to_create) {
+		/* Add ltt ust event to map */
+		add_unique_ust_event(umap->events, uevent, key);
+	}
+
+	if (!usess->active) {
+		goto end;
+	}
+
+	if (to_create) {
+		/* Create event on all UST registered apps for session */
+		ret = ust_app_create_map_event_glb(usess, umap, uevent);
+	} else {
+		/* Enable event on all UST registered apps for session */
+		ret = ust_app_enable_map_event_glb(usess, umap, uevent);
+	}
+
+	if (ret < 0) {
+		if (ret == -LTTNG_UST_ERR_EXIST) {
+			ret_code = LTTNG_ERR_UST_EVENT_EXIST;
+			goto end;
+		} else {
+			ret_code = LTTNG_ERR_UST_ENABLE_FAIL;
+			goto error;
+		}
+	}
+
+	DBG("Event UST %s %s in map %s", uevent->attr.name,
+			to_create ? "created" : "enabled", umap->name);
+
+	ret_code = LTTNG_OK;
+
+end:
+	rcu_read_unlock();
+	free(filter_expression);
+	free(filter);
+	free(exclusion);
+	return ret_code;
+
+error:
+	/*
+	 * Only destroy event on creation time (not enabling time) because if the
+	 * event is found in the map (to_create == 0), it means that at some
+	 * point the enable_event worked and it's thus valid to keep it alive.
+	 * Destroying it also implies that we also destroy it's shadow copy to sync
+	 * everyone up.
+	 */
+	if (to_create) {
+		/* In this code path, the uevent was not added to the hash table */
+		trace_ust_destroy_event(uevent);
+	}
+	rcu_read_unlock();
+	free(filter_expression);
+	free(filter);
+	free(exclusion);
+	return ret_code;
+}
+
 /*
  * Disable UST tracepoint of a channel from a UST session.
  */
 int event_ust_disable_tracepoint(struct ltt_ust_session *usess,
-		struct ltt_ust_channel *uchan, char *event_name)
+		struct ltt_ust_channel *uchan, const char *event_name)
 {
 	int ret;
 	struct ltt_ust_event *uevent;
@@ -301,17 +535,18 @@ int event_ust_disable_tracepoint(struct ltt_ust_session *usess,
 			/* It's already disabled so everything is OK */
 			goto next;
 		}
+		uevent->enabled = 0;
+		DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
+				uchan->name);
 
-		ret = ust_app_disable_event_glb(usess, uchan, uevent);
+		if (!usess->active) {
+			goto next;
+		}
+		ret = ust_app_disable_channel_event_glb(usess, uchan, uevent);
 		if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 			ret = LTTNG_ERR_UST_DISABLE_FAIL;
 			goto error;
 		}
-		uevent->enabled = 0;
-
-		DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
-				uchan->name);
-
 next:
 		/* Get next duplicate event by name. */
 		cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name,
@@ -326,6 +561,69 @@ error:
 	return ret;
 }
 
+/*
+ * Disable UST tracepoint of a map from a UST session.
+ */
+enum lttng_error_code map_event_ust_disable_tracepoint(
+		struct ltt_ust_session *usess,
+		struct ltt_ust_map *umap,
+		uint64_t tracer_token,
+		char *event_name,
+		struct lttng_map_key *key,
+		enum lttng_event_type ev_type,
+		enum lttng_loglevel_type ev_loglevel_type,
+		int ev_loglevel_value,
+		char *filter_expression,
+		struct lttng_bytecode *filter,
+		struct lttng_event_exclusion *exclusion,
+		bool internal_event)
+{
+	int ret;
+	enum lttng_error_code ret_code;
+	struct ltt_ust_event *uevent;
+
+	assert(usess);
+	assert(umap);
+	assert(event_name);
+
+	rcu_read_lock();
+
+	/*
+	 * FIXME: frdeso: We need to pass all the parameters to find the right
+	 * event.
+	 */
+	uevent = trace_ust_find_event(umap->events, tracer_token, event_name, filter,
+			(enum lttng_ust_loglevel_type) ev_loglevel_type,
+			ev_loglevel_value, exclusion, key);
+	assert(uevent);
+
+	if (uevent->enabled == 0) {
+		ret_code = LTTNG_OK;
+		goto end;
+	}
+
+	uevent->enabled = 0;
+	DBG2("Event UST %s disabled in map %s", uevent->attr.name,
+		umap->name);
+
+	if (!usess->active) {
+		ret_code = LTTNG_OK;
+		goto end;
+	}
+
+	ret = ust_app_disable_map_event_glb(usess, umap, uevent);
+	if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
+		ret_code = LTTNG_ERR_UST_DISABLE_FAIL;
+		goto end;
+	}
+
+	ret_code = LTTNG_OK;
+
+end:
+	rcu_read_unlock();
+	return ret_code;
+}
+
 /*
  * Disable all UST tracepoints for a channel from a UST session.
  */
@@ -379,6 +677,70 @@ error:
 	return ret;
 }
 
+/*
+ * Disable all UST tracepoints for a map from a UST session.
+ */
+int map_event_ust_disable_all_tracepoints(struct ltt_ust_session *usess,
+		struct ltt_ust_map *umap)
+{
+	int ret, error = 0;
+	struct lttng_ht_iter iter;
+	struct ltt_ust_event *uevent = NULL;
+	struct lttng_event *events = NULL;
+
+	assert(usess);
+	assert(umap);
+
+	rcu_read_lock();
+
+	/* Disabling existing events */
+	cds_lfht_for_each_entry(umap->events->ht, &iter.iter, uevent,
+			node.node) {
+		if (uevent->enabled == 1) {
+			ret = map_event_ust_disable_tracepoint(usess, umap,
+					uevent->attr.token,
+					uevent->attr.name,
+					uevent->key,
+					uevent->attr.instrumentation,
+					(enum lttng_loglevel_type) uevent->attr.loglevel_type,
+					uevent->attr.loglevel,
+					uevent->filter_expression,
+					uevent->filter,
+					uevent->exclusion,
+					false);
+			if (ret < 0) {
+				error = LTTNG_ERR_UST_DISABLE_FAIL;
+				continue;
+			}
+		}
+	}
+
+	/*
+	 * FIXME: FRDESO: in the equivalent function
+	 * event_ust_disable_all_tracepoints() (above ^) we also iterator over
+	 * all lttng_event. Do we need to do this here too?
+	 */
+
+	ret = error ? error : LTTNG_OK;
+	rcu_read_unlock();
+	free(events);
+	return ret;
+}
+
+static void agent_enable_all(struct agent *agt)
+{
+	struct agent_event *aevent;
+	struct lttng_ht_iter iter;
+
+	/* Flag every event as enabled. */
+	rcu_read_lock();
+	cds_lfht_for_each_entry (
+			agt->events->ht, &iter.iter, aevent, node.node) {
+		aevent->enabled_count++;
+	}
+	rcu_read_unlock();
+}
+
 /*
  * Enable all agent event for a given UST session.
  *
@@ -386,11 +748,9 @@ error:
  */
 int event_agent_enable_all(struct ltt_ust_session *usess,
 		struct agent *agt, struct lttng_event *event,
-		struct lttng_filter_bytecode *filter ,char *filter_expression)
+		struct lttng_bytecode *filter ,char *filter_expression)
 {
 	int ret;
-	struct agent_event *aevent;
-	struct lttng_ht_iter iter;
 
 	assert(usess);
 
@@ -402,13 +762,7 @@ int event_agent_enable_all(struct ltt_ust_session *usess,
 		goto error;
 	}
 
-	/* Flag every event that they are now enabled. */
-	rcu_read_lock();
-	cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
-			node.node) {
-		aevent->enabled = 1;
-	}
-	rcu_read_unlock();
+	agent_enable_all(agt);
 
 	ret = LTTNG_OK;
 
@@ -417,29 +771,82 @@ error:
 }
 
 /*
- * Enable a single agent event for a given UST session.
- *
- * Return LTTNG_OK on success or else a LTTNG_ERR* code.
+ * Check if this event's filter requires the activation of application contexts
+ * and enable them in the agent.
+ * TODO: bytecode iterator does not support non-legacy application
+ * contexts yet. Not an issue for now, since they are not generated by
+ * the lttng-ctl library.
  */
-int event_agent_enable(struct ltt_ust_session *usess,
-		struct agent *agt, struct lttng_event *event,
-		struct lttng_filter_bytecode *filter,
+static int add_filter_app_ctx(struct lttng_bytecode *bytecode,
+		const char *filter_expression, struct agent *agt)
+{
+	int ret = LTTNG_OK;
+	char *provider_name = NULL, *ctx_name = NULL;
+	struct bytecode_symbol_iterator *it =
+			bytecode_symbol_iterator_create(bytecode);
+
+	if (!it) {
+		ret = LTTNG_ERR_NOMEM;
+		goto end;
+	}
+
+	do {
+		struct lttng_event_context ctx;
+		const char *symbol_name =
+				bytecode_symbol_iterator_get_name(it);
+
+		if (parse_application_context(symbol_name, &provider_name,
+				&ctx_name)) {
+			/* Not an application context. */
+			continue;
+		}
+
+		ctx.ctx = LTTNG_EVENT_CONTEXT_APP_CONTEXT;
+		ctx.u.app_ctx.provider_name = provider_name;
+		ctx.u.app_ctx.ctx_name = ctx_name;
+
+		/* Recognized an application context. */
+		DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
+				filter_expression, provider_name, ctx_name);
+
+		ret = agent_add_context(&ctx, agt);
+		if (ret != LTTNG_OK) {
+			ERR("Failed to add application context %s:%s.",
+					provider_name, ctx_name);
+			goto end;
+		}
+
+		ret = agent_enable_context(&ctx, agt->domain);
+		if (ret != LTTNG_OK) {
+			ERR("Failed to enable application context %s:%s.",
+					provider_name, ctx_name);
+			goto end;
+		}
+
+		free(provider_name);
+		free(ctx_name);
+		provider_name = ctx_name = NULL;
+	} while (bytecode_symbol_iterator_next(it) == 0);
+end:
+	free(provider_name);
+	free(ctx_name);
+	bytecode_symbol_iterator_destroy(it);
+	return ret;
+}
+
+static int agent_enable(struct agent *agt,
+		struct lttng_event *event,
+		struct lttng_bytecode *filter,
 		char *filter_expression)
 {
 	int ret, created = 0;
 	struct agent_event *aevent;
 
-	assert(usess);
 	assert(event);
 	assert(agt);
 
-	DBG("Event agent enabling %s for session %" PRIu64 " with loglevel type %d "
-			", loglevel %d and filter \"%s\"", event->name,
-			usess->id, event->loglevel_type, event->loglevel,
-			filter_expression ? filter_expression : "NULL");
-
 	aevent = agent_find_event(event->name, event->loglevel_type,
-		event->loglevel, filter_expression, agt);
+			event->loglevel, filter_expression, agt);
 	if (!aevent) {
 		aevent = agent_create_event(event->name, event->loglevel_type,
 				event->loglevel, filter,
@@ -448,11 +855,23 @@ int event_agent_enable(struct ltt_ust_session *usess,
 			ret = LTTNG_ERR_NOMEM;
 			goto error;
 		}
+		filter = NULL;
+		filter_expression = NULL;
 		created = 1;
+		assert(!AGENT_EVENT_IS_ENABLED(aevent));
+	}
+
+	if (created && aevent->filter) {
+		ret = add_filter_app_ctx(
+				aevent->filter, aevent->filter_expression, agt);
+		if (ret != LTTNG_OK) {
+			goto error;
+		}
 	}
 
 	/* Already enabled? */
-	if (aevent->enabled) {
+	if (AGENT_EVENT_IS_ENABLED(aevent)) {
+		ret = LTTNG_OK;
 		goto end;
 	}
 
@@ -466,13 +885,129 @@ int event_agent_enable(struct ltt_ust_session *usess,
 		agent_add_event(aevent, agt);
 	}
 
-end:
-	return LTTNG_OK;
+	ret = LTTNG_OK;
+	goto end;
 
 error:
 	if (created) {
 		agent_destroy_event(aevent);
 	}
+end:
+	free(filter);
+	free(filter_expression);
+	return ret;
+}
+
+/*
+ * Enable a single agent event for a given UST session.
+ *
+ * Return LTTNG_OK on success or else a LTTNG_ERR* code.
+ */
+int event_agent_enable(struct ltt_ust_session *usess,
+		struct agent *agt,
+		struct lttng_event *event,
+		struct lttng_bytecode *filter,
+		char *filter_expression)
+{
+	assert(usess);
+	assert(event);
+	assert(agt);
+
+	DBG("Enabling agent event: event pattern = '%s', session id = %" PRIu64 ", loglevel type = %d, loglevel = %d, filter expression = '%s'",
+			event->name, usess->id, event->loglevel_type,
+			event->loglevel,
+			filter_expression ? filter_expression : "(none)");
+
+	return agent_enable(agt, event, filter, filter_expression);
+}
+
+/*
+ * Enable a single agent event for a trigger.
+ *
+ * Return LTTNG_OK on success or else a LTTNG_ERR* code.
+ */
+int trigger_agent_enable(const struct lttng_trigger *trigger, struct agent *agt)
+{
+	int ret;
+	enum lttng_condition_status c_status;
+	enum lttng_trigger_status t_status;
+	enum lttng_domain_type d_type;
+	const struct lttng_condition *condition;
+	const struct lttng_event_rule *rule;
+	const char *filter_expression;
+	char *filter_expression_copy = NULL;
+	const struct lttng_bytecode *filter_bytecode;
+	struct lttng_bytecode *filter_bytecode_copy = NULL;
+	struct lttng_event *event = NULL;
+	uid_t trigger_owner_uid = 0;
+	const char *trigger_name;
+
+	assert(trigger);
+	assert(agt);
+
+	t_status = lttng_trigger_get_name(trigger, &trigger_name);
+	if (t_status != LTTNG_TRIGGER_STATUS_OK) {
+		trigger_name = "(unnamed)";
+	}
+
+	t_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner_uid);
+	assert(t_status == LTTNG_TRIGGER_STATUS_OK);
+
+	condition = lttng_trigger_get_const_condition(trigger);
+
+	assert(lttng_condition_get_type(condition) ==
+			LTTNG_CONDITION_TYPE_ON_EVENT);
+
+	c_status = lttng_condition_on_event_get_rule(condition, &rule);
+	assert(c_status == LTTNG_CONDITION_STATUS_OK);
+
+	assert(lttng_event_rule_get_type(rule) ==
+			LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
+
+	d_type = lttng_event_rule_get_domain_type(rule);
+	assert(d_type == agt->domain);
+
+	event = lttng_event_rule_generate_lttng_event(rule);
+	if (!event) {
+		ret = LTTNG_ERR_NOMEM;
+		goto end;
+	}
+
+	/* Get the internal filter expression and bytecode. */
+	filter_expression = lttng_event_rule_get_filter(rule);
+	if (filter_expression) {
+		filter_expression_copy = strdup(filter_expression);
+		if (!filter_expression_copy) {
+			ret = LTTNG_ERR_NOMEM;
+			goto end;
+		}
+
+		/* Get the filter bytecode */
+		filter_bytecode = lttng_event_rule_get_filter_bytecode(rule);
+		if (filter_bytecode) {
+			filter_bytecode_copy =
+					lttng_bytecode_copy(filter_bytecode);
+			if (!filter_bytecode_copy) {
+				ret = LTTNG_ERR_NOMEM;
+				goto end;
+			}
+		}
+	}
+
+	DBG("Enabling agent event from trigger: trigger name = '%s', trigger owner uid = %d, token = %" PRIu64,
+			trigger_name, trigger_owner_uid,
+			lttng_trigger_get_tracer_token(trigger));
+
+	ret = agent_enable(agt, event, filter_bytecode_copy,
+			filter_expression_copy);
+	/* Ownership was passed even in case of error. */
+	filter_expression_copy = NULL;
+	filter_bytecode_copy = NULL;
+
+end:
+	free(filter_expression_copy);
+	free(filter_bytecode_copy);
+	free(event);
 	return ret;
 }
 
@@ -501,6 +1036,43 @@ const char *event_get_default_agent_ust_name(enum lttng_domain_type domain)
 	return default_event_name;
 }
 
+static int trigger_agent_disable_one(const struct lttng_trigger *trigger,
+		struct agent *agt,
+		struct agent_event *aevent)
+
+{
+	int ret;
+
+	assert(agt);
+	assert(trigger);
+	assert(aevent);
+
+	/*
+	 * Actual ust event un-registration happens on the trigger
+	 * un-registration at that point.
+	 */
+
+	DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for trigger %" PRIu64,
+			aevent->name, aevent->loglevel_type,
+			aevent->loglevel_value, lttng_trigger_get_tracer_token(trigger));
+
+	/* Already disabled? */
+	if (!AGENT_EVENT_IS_ENABLED(aevent)) {
+		goto end;
+	}
+
+	ret = agent_disable_event(aevent, agt->domain);
+	if (ret != LTTNG_OK) {
+		goto error;
+	}
+
+end:
+	return LTTNG_OK;
+
+error:
+	return ret;
+}
+
 /*
  * Disable a given agent event for a given UST session.
  *
@@ -524,7 +1096,7 @@ static int event_agent_disable_one(struct ltt_ust_session *usess,
 		usess->id);
 
 	/* Already disabled? */
-	if (!aevent->enabled) {
+	if (!AGENT_EVENT_IS_ENABLED(aevent)) {
 		goto end;
 	}
 
@@ -562,15 +1134,19 @@ static int event_agent_disable_one(struct ltt_ust_session *usess,
 	 * happens thanks to an UST filter. The following -1 is actually
 	 * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
 	 */
-	uevent = trace_ust_find_event(uchan->events, (char *) ust_event_name,
-			aevent->filter, LTTNG_UST_LOGLEVEL_ALL, -1, NULL);
+	/* TODO: JORAJ FRDESO: hmmm what to do with tracer token here?
+	 */
+	uevent = trace_ust_find_event(uchan->events, 0, (char *) ust_event_name,
+			aevent->filter, LTTNG_UST_LOGLEVEL_ALL, -1, NULL, NULL);
 	/* If the agent event exists, it must be available on the UST side. */
 	assert(uevent);
 
-	ret = ust_app_disable_event_glb(usess, uchan, uevent);
-	if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
-		ret = LTTNG_ERR_UST_DISABLE_FAIL;
-		goto error;
+	if (usess->active) {
+		ret = ust_app_disable_channel_event_glb(usess, uchan, uevent);
+		if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
+			ret = LTTNG_ERR_UST_DISABLE_FAIL;
+			goto error;
+		}
 	}
 
 	/*
@@ -591,13 +1167,51 @@ error:
 	return ret;
 }
 
+/*
+ * Disable agent event matching a given trigger.
+ *
+ * Return LTTNG_OK on success or else a LTTNG_ERR* code.
+ */
+int trigger_agent_disable(
+		const struct lttng_trigger *trigger, struct agent *agt)
+{
+	int ret = LTTNG_OK;
+	struct agent_event *aevent;
+
+	assert(trigger);
+	assert(agt);
+
+	DBG("Event agent disabling for trigger %" PRIu64,
+			lttng_trigger_get_tracer_token(trigger));
+
+	rcu_read_lock();
+	aevent = agent_find_event_by_trigger(trigger, agt);
+
+	if (aevent == NULL) {
+		DBG2("Event agent NOT found by trigger %" PRIu64,
+				lttng_trigger_get_tracer_token(trigger));
+		ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
+		goto end;
+	}
+
+	ret = trigger_agent_disable_one(trigger, agt, aevent);
+
+	if (ret != LTTNG_OK) {
+		goto end;
+	}
+
+end:
+	rcu_read_unlock();
+	return ret;
+}
+
 /*
  * Disable all agent events matching a given name for a given UST session.
  *
  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
  */
 int event_agent_disable(struct ltt_ust_session *usess, struct agent *agt,
-		char *event_name)
+		const char *event_name)
 {
 	int ret = LTTNG_OK;
 	struct agent_event *aevent;
@@ -664,7 +1278,7 @@ int event_agent_disable_all(struct ltt_ust_session *usess,
 	rcu_read_lock();
 	cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 			node.node) {
-		if (!aevent->enabled) {
+		if (!AGENT_EVENT_IS_ENABLED(aevent)) {
 			continue;
 		}