X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fevent.c;h=97bb69ba88fe01f0af4ff781a89ed581cc1809ea;hb=3a2434036c2e836d58bfa5b89ba47b5898d86d35;hp=40eb2656098b7d0b3ab69a9dd1219b0d5beadf7b;hpb=44760c20f4fc255b63894ca758cf2ee5f253220b;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/event.c b/src/bin/lttng-sessiond/event.c index 40eb26560..97bb69ba8 100644 --- a/src/bin/lttng-sessiond/event.c +++ b/src/bin/lttng-sessiond/event.c @@ -13,9 +13,10 @@ #include #include #include -#include +#include #include #include +#include #include #include #include @@ -42,12 +43,12 @@ static void add_unique_ust_event(struct lttng_ht *ht, 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; @@ -55,7 +56,7 @@ static void add_unique_ust_event(struct lttng_ht *ht, 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); } /* @@ -70,7 +71,7 @@ int event_kernel_disable_event(struct ltt_kernel_channel *kchan, 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) { @@ -104,13 +105,13 @@ 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; - assert(kchan); - assert(event); + LTTNG_ASSERT(kchan); + LTTNG_ASSERT(event); kevent = trace_kernel_find_event(event->name, kchan, event->type, filter); @@ -154,21 +155,21 @@ 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; - 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, @@ -178,7 +179,7 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess, 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 */ @@ -187,7 +188,7 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess, 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; } @@ -213,11 +214,10 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess, 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, @@ -231,24 +231,6 @@ end: 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; } /* @@ -263,9 +245,9 @@ int event_ust_disable_tracepoint(struct ltt_ust_session *usess, 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; @@ -286,7 +268,7 @@ int event_ust_disable_tracepoint(struct ltt_ust_session *usess, 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 */ @@ -329,8 +311,8 @@ int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess, struct ltt_ust_event *uevent = NULL; struct lttng_event *events = NULL; - assert(usess); - assert(uchan); + LTTNG_ASSERT(usess); + LTTNG_ASSERT(uchan); rcu_read_lock(); @@ -392,11 +374,11 @@ static void agent_enable_all(struct agent *agt) */ 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; - assert(usess); + LTTNG_ASSERT(usess); DBG("Event agent enabling ALL events for session %" PRIu64, usess->id); @@ -421,7 +403,7 @@ error: * 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; @@ -480,14 +462,14 @@ end: 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; struct agent_event *aevent; - assert(event); - assert(agt); + LTTNG_ASSERT(event); + LTTNG_ASSERT(agt); aevent = agent_find_event(event->name, event->loglevel_type, event->loglevel, filter_expression, agt); @@ -502,7 +484,7 @@ static int agent_enable(struct agent *agt, filter = NULL; filter_expression = NULL; created = 1; - assert(!AGENT_EVENT_IS_ENABLED(aevent)); + LTTNG_ASSERT(!AGENT_EVENT_IS_ENABLED(aevent)); } if (created && aevent->filter) { @@ -550,12 +532,12 @@ end: 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); - assert(event); - assert(agt); + 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, @@ -580,36 +562,44 @@ int trigger_agent_enable(const struct lttng_trigger *trigger, struct agent *agt) 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; - assert(trigger); - assert(agt); + LTTNG_ASSERT(trigger); + LTTNG_ASSERT(agt); 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); - assert(t_status == LTTNG_TRIGGER_STATUS_OK); + LTTNG_ASSERT(t_status == LTTNG_TRIGGER_STATUS_OK); condition = lttng_trigger_get_const_condition(trigger); - assert(lttng_condition_get_type(condition) == - LTTNG_CONDITION_TYPE_EVENT_RULE_HIT); + LTTNG_ASSERT(lttng_condition_get_type(condition) == + LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES); - c_status = lttng_condition_event_rule_get_rule(condition, &rule); - assert(c_status == LTTNG_CONDITION_STATUS_OK); + c_status = lttng_condition_event_rule_matches_get_rule( + condition, &rule); + LTTNG_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); + LTTNG_ASSERT(d_type == agt->domain); event = lttng_event_rule_generate_lttng_event(rule); if (!event) { @@ -630,7 +620,7 @@ int trigger_agent_enable(const struct lttng_trigger *trigger, struct agent *agt) 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; @@ -674,7 +664,7 @@ const char *event_get_default_agent_ust_name(enum lttng_domain_type domain) default_event_name = DEFAULT_PYTHON_EVENT_NAME; break; default: - assert(0); + abort(); } return default_event_name; @@ -687,9 +677,9 @@ static int trigger_agent_disable_one(const struct lttng_trigger *trigger, { int ret; - assert(agt); - assert(trigger); - assert(aevent); + LTTNG_ASSERT(agt); + LTTNG_ASSERT(trigger); + LTTNG_ASSERT(aevent); /* * Actual ust event un-registration happens on the trigger @@ -731,9 +721,9 @@ static int event_agent_disable_one(struct ltt_ust_session *usess, 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, @@ -779,9 +769,9 @@ static int event_agent_disable_one(struct ltt_ust_session *usess, * 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); @@ -820,8 +810,8 @@ int trigger_agent_disable( int ret = LTTNG_OK; struct agent_event *aevent; - assert(trigger); - assert(agt); + LTTNG_ASSERT(trigger); + LTTNG_ASSERT(agt); DBG("Event agent disabling for trigger %" PRIu64, lttng_trigger_get_tracer_token(trigger)); @@ -860,9 +850,9 @@ int event_agent_disable(struct ltt_ust_session *usess, struct agent *agt, 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); @@ -904,8 +894,8 @@ int event_agent_disable_all(struct ltt_ust_session *usess, 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