*/
#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/event-rule-matches.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 "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.
struct cds_lfht_node *node_ptr;
struct ltt_ust_ht_key key;
- assert(ht);
- assert(ht->ht);
- assert(event);
+ LTTNG_ASSERT(ht);
+ LTTNG_ASSERT(ht->ht);
+ LTTNG_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;
node_ptr = cds_lfht_add_unique(ht->ht,
ht->hash_fct(event->node.key, lttng_ht_seed),
trace_ust_ht_match_event, &key, &event->node.node);
- assert(node_ptr == &event->node.node);
+ LTTNG_ASSERT(node_ptr == &event->node.node);
}
/*
int ret, error = 0, found = 0;
struct ltt_kernel_event *kevent;
- assert(kchan);
+ LTTNG_ASSERT(kchan);
/* For each event in the kernel session */
cds_list_for_each_entry(kevent, &kchan->events_list.head, list) {
*/
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;
- assert(kchan);
- assert(event);
+ LTTNG_ASSERT(kchan);
+ LTTNG_ASSERT(event);
kevent = trace_kernel_find_event(event->name, kchan,
event->type, filter);
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;
- assert(usess);
- assert(uchan);
- assert(event);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(uchan);
+ LTTNG_ASSERT(event);
rcu_read_lock();
uevent = trace_ust_find_event(uchan->events, event->name, filter,
- (enum lttng_ust_loglevel_type) event->loglevel_type,
+ (enum lttng_ust_abi_loglevel_type) event->loglevel_type,
event->loglevel, exclusion);
if (!uevent) {
ret = trace_ust_create_event(event, filter_expression,
filter = NULL;
exclusion = NULL;
if (ret != LTTNG_OK) {
- goto error;
+ goto end;
}
/* Valid to set it after the goto error since uevent is still NULL */
if (uevent->enabled) {
/* It's already enabled so everything is OK */
- assert(!to_create);
+ LTTNG_ASSERT(!to_create);
ret = LTTNG_ERR_UST_EVENT_ENABLED;
goto end;
}
if (ret < 0) {
if (ret == -LTTNG_UST_ERR_EXIST) {
ret = LTTNG_ERR_UST_EVENT_EXIST;
- goto end;
} else {
ret = LTTNG_ERR_UST_ENABLE_FAIL;
- goto error;
}
+ goto end;
}
DBG("Event UST %s %s in channel %s", uevent->attr.name,
free(filter);
free(exclusion);
return ret;
-
-error:
- /*
- * Only destroy event on creation time (not enabling time) because if the
- * event is found in the channel (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;
}
/*
struct lttng_ht_iter iter;
struct lttng_ht *ht;
- assert(usess);
- assert(uchan);
- assert(event_name);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(uchan);
+ LTTNG_ASSERT(event_name);
ht = uchan->events;
do {
uevent = caa_container_of(node, struct ltt_ust_event, node);
- assert(uevent);
+ LTTNG_ASSERT(uevent);
if (uevent->enabled == 0) {
/* It's already disabled so everything is OK */
struct ltt_ust_event *uevent = NULL;
struct lttng_event *events = NULL;
- assert(usess);
- assert(uchan);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(uchan);
rcu_read_lock();
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.
*
*/
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);
+ LTTNG_ASSERT(usess);
DBG("Event agent enabling ALL events for session %" PRIu64, usess->id);
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;
* contexts yet. Not an issue for now, since they are not generated by
* the lttng-ctl library.
*/
-static int add_filter_app_ctx(struct lttng_filter_bytecode *bytecode,
+static int add_filter_app_ctx(struct lttng_bytecode *bytecode,
const char *filter_expression, struct agent *agt)
{
int ret = LTTNG_OK;
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_filter_bytecode *filter,
+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");
+ LTTNG_ASSERT(event);
+ LTTNG_ASSERT(agt);
aevent = agent_find_event(event->name, event->loglevel_type,
event->loglevel, filter_expression, agt);
filter = NULL;
filter_expression = NULL;
created = 1;
- assert(!aevent->enabled);
+ LTTNG_ASSERT(!AGENT_EVENT_IS_ENABLED(aevent));
}
if (created && aevent->filter) {
}
/* Already enabled? */
- if (aevent->enabled) {
+ if (AGENT_EVENT_IS_ENABLED(aevent)) {
ret = LTTNG_OK;
goto end;
}
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)
+{
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(event);
+ LTTNG_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;
+
+ LTTNG_ASSERT(trigger);
+ LTTNG_ASSERT(agt);
+
+ t_status = lttng_trigger_get_name(trigger, &trigger_name);
+ if (t_status != LTTNG_TRIGGER_STATUS_OK) {
+ trigger_name = "(anonymous)";
+ }
+
+ t_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner_uid);
+ LTTNG_ASSERT(t_status == LTTNG_TRIGGER_STATUS_OK);
+
+ condition = lttng_trigger_get_const_condition(trigger);
+
+ LTTNG_ASSERT(lttng_condition_get_type(condition) ==
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
+
+ c_status = lttng_condition_event_rule_matches_get_rule(
+ condition, &rule);
+ LTTNG_ASSERT(c_status == LTTNG_CONDITION_STATUS_OK);
+
+ switch (lttng_event_rule_get_type(rule)) {
+ case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
+ case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
+ case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
+ break;
+ default:
+ abort();
+ break;
+ }
+
+ d_type = lttng_event_rule_get_domain_type(rule);
+ LTTNG_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;
+}
+
/*
* Return the default event name associated with the provided UST domain. Return
* NULL on error.
default_event_name = DEFAULT_PYTHON_EVENT_NAME;
break;
default:
- assert(0);
+ abort();
}
return default_event_name;
}
+static int trigger_agent_disable_one(const struct lttng_trigger *trigger,
+ struct agent *agt,
+ struct agent_event *aevent)
+
+{
+ int ret;
+
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(trigger);
+ LTTNG_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.
*
struct ltt_ust_channel *uchan = NULL;
const char *ust_event_name, *ust_channel_name;
- assert(agt);
- assert(usess);
- assert(aevent);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(aevent);
DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64,
aevent->name, aevent->loglevel_type, aevent->loglevel_value,
usess->id);
/* Already disabled? */
- if (!aevent->enabled) {
+ if (!AGENT_EVENT_IS_ENABLED(aevent)) {
goto end;
}
* 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);
+ aevent->filter, LTTNG_UST_ABI_LOGLEVEL_ALL, -1, NULL);
/* If the agent event exists, it must be available on the UST side. */
- assert(uevent);
+ LTTNG_ASSERT(uevent);
if (usess->active) {
ret = ust_app_disable_event_glb(usess, uchan, uevent);
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;
+
+ LTTNG_ASSERT(trigger);
+ LTTNG_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.
*
struct lttng_ht_iter iter;
struct lttng_ht_node_str *node;
- assert(agt);
- assert(usess);
- assert(event_name);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(event_name);
DBG("Event agent disabling %s (all loglevels) for session %" PRIu64, event_name, usess->id);
struct agent_event *aevent;
struct lttng_ht_iter iter;
- assert(agt);
- assert(usess);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(usess);
/*
* Disable event on agent application. Continue to disable all other events
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;
}
projects / lttng-tools.git / blobdiff