/*
- * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011 EfficiOS Inc.
* Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
* SPDX-License-Identifier: GPL-2.0-only
#include <common/compat/errno.h>
#include <lttng/lttng.h>
#include <lttng/condition/condition.h>
-#include <lttng/condition/event-rule.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>
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;
*/
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;
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)
{
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 (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;
}
/*
*/
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;
* 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;
static int agent_enable(struct agent *agt,
struct lttng_event *event,
- struct lttng_filter_bytecode *filter,
+ struct lttng_bytecode *filter,
char *filter_expression)
{
int ret, created = 0;
assert(event);
assert(agt);
+ rcu_read_lock();
aevent = agent_find_event(event->name, event->loglevel_type,
event->loglevel, filter_expression, agt);
if (!aevent) {
agent_destroy_event(aevent);
}
end:
+ rcu_read_unlock();
free(filter);
free(filter_expression);
return ret;
int event_agent_enable(struct ltt_ust_session *usess,
struct agent *agt,
struct lttng_event *event,
- struct lttng_filter_bytecode *filter,
+ struct lttng_bytecode *filter,
char *filter_expression)
{
assert(usess);
const struct lttng_event_rule *rule;
const char *filter_expression;
char *filter_expression_copy = NULL;
- const struct lttng_filter_bytecode *filter_bytecode;
- struct lttng_filter_bytecode *filter_bytecode_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;
t_status = lttng_trigger_get_name(trigger, &trigger_name);
if (t_status != LTTNG_TRIGGER_STATUS_OK) {
- trigger_name = "(unnamed)";
+ trigger_name = "(anonymous)";
}
t_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner_uid);
condition = lttng_trigger_get_const_condition(trigger);
assert(lttng_condition_get_type(condition) ==
- LTTNG_CONDITION_TYPE_EVENT_RULE_HIT);
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
- c_status = lttng_condition_event_rule_get_rule(condition, &rule);
+ c_status = lttng_condition_event_rule_matches_get_rule(
+ condition, &rule);
assert(c_status == LTTNG_CONDITION_STATUS_OK);
- assert(lttng_event_rule_get_type(rule) ==
- LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
+ 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);
assert(d_type == agt->domain);
filter_bytecode = lttng_event_rule_get_filter_bytecode(rule);
if (filter_bytecode) {
filter_bytecode_copy =
- lttng_filter_bytecode_copy(filter_bytecode);
+ lttng_bytecode_copy(filter_bytecode);
if (!filter_bytecode_copy) {
ret = LTTNG_ERR_NOMEM;
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);