X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=liblttng-ust%2Flttng-events.c;h=330737fe96cd196bc6a1b2f83c394532b0ac75ed;hb=68bb7559b0041c38158c9ed0528d91d655e7eb6c;hp=6a089122c8d1a2afee87f1a77e353aa4d7467736;hpb=ebabbf580131acd1fe246c4d31fc5c044d36a038;p=lttng-ust.git diff --git a/liblttng-ust/lttng-events.c b/liblttng-ust/lttng-events.c index 6a089122..330737fe 100644 --- a/liblttng-ust/lttng-events.c +++ b/liblttng-ust/lttng-events.c @@ -1,23 +1,9 @@ /* - * lttng-events.c - * - * Holds LTTng per-session event registry. + * SPDX-License-Identifier: LGPL-2.1-only * * Copyright (C) 2010-2012 Mathieu Desnoyers * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; only - * version 2.1 of the License. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * Holds LTTng per-session event registry. */ #define _LGPL_SOURCE @@ -34,9 +20,9 @@ #include #include #include +#include #include -#include #include #include #include @@ -47,12 +33,12 @@ #include #include -#include +#include #include #include #include -#include -#include +#include +#include #include "error.h" #include "compat.h" #include "lttng-ust-uuid.h" @@ -79,7 +65,7 @@ static CDS_LIST_HEAD(sessions); static CDS_LIST_HEAD(event_notifier_groups); -struct cds_list_head *_lttng_get_sessions(void) +struct cds_list_head *lttng_get_sessions(void) { return &sessions; } @@ -143,11 +129,6 @@ int lttng_loglevel_match(int loglevel, } } -void synchronize_trace(void) -{ - synchronize_rcu(); -} - struct lttng_session *lttng_session_create(void) { struct lttng_session *session; @@ -263,14 +244,14 @@ void register_event(struct lttng_event *event) int ret; const struct lttng_event_desc *desc; - assert(event->registered == 0); - desc = event->desc; + assert(event->priv->registered == 0); + desc = event->priv->desc; ret = __tracepoint_probe_register_queue_release(desc->name, desc->probe_callback, event, desc->signature); WARN_ON_ONCE(ret); if (!ret) - event->registered = 1; + event->priv->registered = 1; } static @@ -294,14 +275,14 @@ void unregister_event(struct lttng_event *event) int ret; const struct lttng_event_desc *desc; - assert(event->registered == 1); - desc = event->desc; + assert(event->priv->registered == 1); + desc = event->priv->desc; ret = __tracepoint_probe_unregister_queue_release(desc->name, desc->probe_callback, event); WARN_ON_ONCE(ret); if (!ret) - event->registered = 0; + event->priv->registered = 0; } static @@ -325,7 +306,7 @@ void unregister_event_notifier(struct lttng_event_notifier *event_notifier) static void _lttng_event_unregister(struct lttng_event *event) { - if (event->registered) + if (event->priv->registered) unregister_event(event); } @@ -342,22 +323,22 @@ void _lttng_event_notifier_unregister(struct lttng_event_notifier *event_notifie void lttng_session_destroy(struct lttng_session *session) { struct lttng_channel *chan, *tmpchan; - struct lttng_event *event, *tmpevent; + struct lttng_ust_event_private *event_priv, *tmpevent_priv; struct lttng_enum *_enum, *tmp_enum; struct lttng_event_enabler *event_enabler, *event_tmpenabler; CMM_ACCESS_ONCE(session->active) = 0; - cds_list_for_each_entry(event, &session->events_head, node) { - _lttng_event_unregister(event); + cds_list_for_each_entry(event_priv, &session->events_head, node) { + _lttng_event_unregister(event_priv->pub); } - synchronize_trace(); /* Wait for in-flight events to complete */ + lttng_ust_urcu_synchronize_rcu(); /* Wait for in-flight events to complete */ __tracepoint_probe_prune_release_queue(); cds_list_for_each_entry_safe(event_enabler, event_tmpenabler, &session->enablers_head, node) lttng_event_enabler_destroy(event_enabler); - cds_list_for_each_entry_safe(event, tmpevent, + cds_list_for_each_entry_safe(event_priv, tmpevent_priv, &session->events_head, node) - _lttng_event_destroy(event); + _lttng_event_destroy(event_priv->pub); cds_list_for_each_entry_safe(_enum, tmp_enum, &session->enums_head, node) _lttng_enum_destroy(_enum); @@ -383,7 +364,7 @@ void lttng_event_notifier_group_destroy( &event_notifier_group->event_notifiers_head, node) _lttng_event_notifier_unregister(notifier); - synchronize_trace(); + lttng_ust_urcu_synchronize_rcu(); cds_list_for_each_entry_safe(notifier_enabler, tmpnotifier_enabler, &event_notifier_group->enablers_head, node) @@ -762,6 +743,7 @@ int lttng_event_create(const struct lttng_event_desc *desc, struct lttng_channel *chan) { struct lttng_event *event; + struct lttng_ust_event_private *event_priv; struct lttng_session *session = chan->session; struct cds_hlist_head *head; int ret = 0; @@ -792,17 +774,24 @@ int lttng_event_create(const struct lttng_event_desc *desc, ret = -ENOMEM; goto cache_error; } + event_priv = zmalloc(sizeof(struct lttng_ust_event_private)); + if (!event_priv) { + ret = -ENOMEM; + goto priv_error; + } + event->priv = event_priv; + event_priv->pub = event; event->chan = chan; /* Event will be enabled by enabler sync. */ event->enabled = 0; - event->registered = 0; + event->priv->registered = 0; CDS_INIT_LIST_HEAD(&event->filter_bytecode_runtime_head); - CDS_INIT_LIST_HEAD(&event->enablers_ref_head); - event->desc = desc; + CDS_INIT_LIST_HEAD(&event->priv->enablers_ref_head); + event->priv->desc = desc; if (desc->loglevel) - loglevel = *(*event->desc->loglevel); + loglevel = *(*event->priv->desc->loglevel); else loglevel = TRACE_DEFAULT; if (desc->u.ext.model_emf_uri) @@ -827,11 +816,13 @@ int lttng_event_create(const struct lttng_event_desc *desc, goto sessiond_register_error; } - cds_list_add(&event->node, &chan->session->events_head); - cds_hlist_add_head(&event->hlist, head); + cds_list_add(&event->priv->node, &chan->session->events_head); + cds_hlist_add_head(&event->priv->hlist, head); return 0; sessiond_register_error: + free(event_priv); +priv_error: free(event); cache_error: create_enum_error: @@ -841,7 +832,7 @@ socket_error: static int lttng_event_notifier_create(const struct lttng_event_desc *desc, - uint64_t token, + uint64_t token, uint64_t error_counter_index, struct lttng_event_notifier_group *event_notifier_group) { struct lttng_event_notifier *event_notifier; @@ -864,6 +855,7 @@ int lttng_event_notifier_create(const struct lttng_event_desc *desc, event_notifier->group = event_notifier_group; event_notifier->user_token = token; + event_notifier->error_counter_index = error_counter_index; /* Event notifier will be enabled by enabler sync. */ event_notifier->enabled = 0; @@ -873,6 +865,7 @@ int lttng_event_notifier_create(const struct lttng_event_desc *desc, CDS_INIT_LIST_HEAD(&event_notifier->capture_bytecode_runtime_head); CDS_INIT_LIST_HEAD(&event_notifier->enablers_ref_head); event_notifier->desc = desc; + event_notifier->notification_send = lttng_event_notifier_notification_send; cds_list_add(&event_notifier->node, &event_notifier_group->event_notifiers_head); @@ -992,7 +985,7 @@ static int lttng_event_enabler_match_event(struct lttng_event_enabler *event_enabler, struct lttng_event *event) { - if (lttng_desc_match_enabler(event->desc, + if (lttng_desc_match_enabler(event->priv->desc, lttng_event_enabler_as_enabler(event_enabler)) && event->chan == event_enabler->chan) return 1; @@ -1039,7 +1032,7 @@ void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler) struct lttng_session *session = event_enabler->chan->session; struct lttng_probe_desc *probe_desc; const struct lttng_event_desc *desc; - struct lttng_event *event; + struct lttng_ust_event_private *event_priv; int i; struct cds_list_head *probe_list; @@ -1065,9 +1058,9 @@ void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler) session->events_ht.table, LTTNG_UST_EVENT_HT_SIZE, desc); - cds_hlist_for_each_entry(event, node, head, hlist) { - if (event->desc == desc - && event->chan == event_enabler->chan) { + cds_hlist_for_each_entry(event_priv, node, head, hlist) { + if (event_priv->desc == desc + && event_priv->pub->chan == event_enabler->chan) { found = true; break; } @@ -1100,7 +1093,7 @@ void probe_provider_event_for_each(struct lttng_probe_desc *provider_desc, unsigned int i; /* Get handle on list of sessions. */ - sessionsp = _lttng_get_sessions(); + sessionsp = lttng_get_sessions(); /* * Iterate over all events in the probe provider descriptions and @@ -1112,7 +1105,7 @@ void probe_provider_event_for_each(struct lttng_probe_desc *provider_desc, struct lttng_event_notifier *event_notifier; struct lttng_session *session; struct cds_hlist_head *head; - struct lttng_event *event; + struct lttng_ust_event_private *event_priv; event_desc = provider_desc->event_desc[i]; @@ -1129,9 +1122,9 @@ void probe_provider_event_for_each(struct lttng_probe_desc *provider_desc, session->events_ht.table, LTTNG_UST_EVENT_HT_SIZE, event_desc); - cds_hlist_for_each_entry_safe(event, node, tmp_node, head, hlist) { - if (event_desc == event->desc) { - event_func(session, event); + cds_hlist_for_each_entry_safe(event_priv, node, tmp_node, head, hlist) { + if (event_desc == event_priv->desc) { + event_func(session, event_priv->pub); break; } } @@ -1175,12 +1168,12 @@ void _event_enum_destroy(struct lttng_session *session, unsigned int i; /* Destroy enums of the current event. */ - for (i = 0; i < event->desc->nr_fields; i++) { + for (i = 0; i < event->priv->desc->nr_fields; i++) { const struct lttng_enum_desc *enum_desc; const struct lttng_event_field *field; struct lttng_enum *curr_enum; - field = &(event->desc->fields[i]); + field = &(event->priv->desc->fields[i]); switch (field->type.atype) { case atype_enum: enum_desc = field->type.u.legacy.basic.enumeration.desc; @@ -1218,7 +1211,7 @@ void lttng_probe_provider_unregister_events( _lttng_event_notifier_unregister); /* Wait for grace period. */ - synchronize_trace(); + lttng_ust_urcu_synchronize_rcu(); /* Prune the unregistration queue. */ __tracepoint_probe_prune_release_queue(); @@ -1238,7 +1231,7 @@ static int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) { struct lttng_session *session = event_enabler->chan->session; - struct lttng_event *event; + struct lttng_ust_event_private *event_priv; if (!lttng_event_enabler_as_enabler(event_enabler)->enabled) goto end; @@ -1247,13 +1240,13 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) lttng_create_event_if_missing(event_enabler); /* For each event matching enabler in session event list. */ - cds_list_for_each_entry(event, &session->events_head, node) { + cds_list_for_each_entry(event_priv, &session->events_head, node) { struct lttng_enabler_ref *enabler_ref; - if (!lttng_event_enabler_match_event(event_enabler, event)) + if (!lttng_event_enabler_match_event(event_enabler, event_priv->pub)) continue; - enabler_ref = lttng_enabler_ref(&event->enablers_ref_head, + enabler_ref = lttng_enabler_ref(&event_priv->enablers_ref_head, lttng_event_enabler_as_enabler(event_enabler)); if (!enabler_ref) { /* @@ -1266,15 +1259,15 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) enabler_ref->ref = lttng_event_enabler_as_enabler( event_enabler); cds_list_add(&enabler_ref->node, - &event->enablers_ref_head); + &event_priv->enablers_ref_head); } /* * Link filter bytecodes if not linked yet. */ - lttng_enabler_link_bytecode(event->desc, + lttng_enabler_link_bytecode(event_priv->desc, &session->ctx, - &event->filter_bytecode_runtime_head, + &event_priv->pub->filter_bytecode_runtime_head, <tng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head); /* TODO: merge event context. */ @@ -1345,16 +1338,17 @@ void _lttng_event_destroy(struct lttng_event *event) struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref; /* Remove from event list. */ - cds_list_del(&event->node); + cds_list_del(&event->priv->node); /* Remove from event hash table. */ - cds_hlist_del(&event->hlist); + cds_hlist_del(&event->priv->hlist); lttng_destroy_context(event->ctx); lttng_free_event_filter_runtime(event); /* Free event enabler refs */ cds_list_for_each_entry_safe(enabler_ref, tmp_enabler_ref, - &event->enablers_ref_head, node) + &event->priv->enablers_ref_head, node) free(enabler_ref); + free(event->priv); free(event); } @@ -1417,6 +1411,7 @@ struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create( CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.excluder_head); event_notifier_enabler->user_token = event_notifier_param->event.token; + event_notifier_enabler->error_counter_index = event_notifier_param->error_counter_index; event_notifier_enabler->num_captures = 0; memcpy(&event_notifier_enabler->base.event_param.name, @@ -1458,14 +1453,16 @@ int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler) static void _lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler, - struct lttng_ust_bytecode_node *bytecode) + struct lttng_ust_bytecode_node **bytecode) { - bytecode->enabler = enabler; - cds_list_add_tail(&bytecode->node, &enabler->filter_bytecode_head); + (*bytecode)->enabler = enabler; + cds_list_add_tail(&(*bytecode)->node, &enabler->filter_bytecode_head); + /* Take ownership of bytecode */ + *bytecode = NULL; } int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler, - struct lttng_ust_bytecode_node *bytecode) + struct lttng_ust_bytecode_node **bytecode) { _lttng_enabler_attach_filter_bytecode( lttng_event_enabler_as_enabler(event_enabler), bytecode); @@ -1476,14 +1473,16 @@ int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event static void _lttng_enabler_attach_exclusion(struct lttng_enabler *enabler, - struct lttng_ust_excluder_node *excluder) + struct lttng_ust_excluder_node **excluder) { - excluder->enabler = enabler; - cds_list_add_tail(&excluder->node, &enabler->excluder_head); + (*excluder)->enabler = enabler; + cds_list_add_tail(&(*excluder)->node, &enabler->excluder_head); + /* Take ownership of excluder */ + *excluder = NULL; } int lttng_event_enabler_attach_exclusion(struct lttng_event_enabler *event_enabler, - struct lttng_ust_excluder_node *excluder) + struct lttng_ust_excluder_node **excluder) { _lttng_enabler_attach_exclusion( lttng_event_enabler_as_enabler(event_enabler), excluder); @@ -1512,7 +1511,7 @@ int lttng_event_notifier_enabler_disable( int lttng_event_notifier_enabler_attach_filter_bytecode( struct lttng_event_notifier_enabler *event_notifier_enabler, - struct lttng_ust_bytecode_node *bytecode) + struct lttng_ust_bytecode_node **bytecode) { _lttng_enabler_attach_filter_bytecode( lttng_event_notifier_enabler_as_enabler(event_notifier_enabler), @@ -1524,12 +1523,14 @@ int lttng_event_notifier_enabler_attach_filter_bytecode( int lttng_event_notifier_enabler_attach_capture_bytecode( struct lttng_event_notifier_enabler *event_notifier_enabler, - struct lttng_ust_bytecode_node *bytecode) + struct lttng_ust_bytecode_node **bytecode) { - bytecode->enabler = lttng_event_notifier_enabler_as_enabler( + (*bytecode)->enabler = lttng_event_notifier_enabler_as_enabler( event_notifier_enabler); - cds_list_add_tail(&bytecode->node, + cds_list_add_tail(&(*bytecode)->node, &event_notifier_enabler->capture_bytecode_head); + /* Take ownership of bytecode */ + *bytecode = NULL; event_notifier_enabler->num_captures++; lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); @@ -1538,7 +1539,7 @@ int lttng_event_notifier_enabler_attach_capture_bytecode( int lttng_event_notifier_enabler_attach_exclusion( struct lttng_event_notifier_enabler *event_notifier_enabler, - struct lttng_ust_excluder_node *excluder) + struct lttng_ust_excluder_node **excluder) { _lttng_enabler_attach_exclusion( lttng_event_notifier_enabler_as_enabler(event_notifier_enabler), @@ -1647,7 +1648,7 @@ static void lttng_session_sync_event_enablers(struct lttng_session *session) { struct lttng_event_enabler *event_enabler; - struct lttng_event *event; + struct lttng_ust_event_private *event_priv; cds_list_for_each_entry(event_enabler, &session->enablers_head, node) lttng_event_enabler_ref_events(event_enabler); @@ -1656,14 +1657,14 @@ void lttng_session_sync_event_enablers(struct lttng_session *session) * and its channel and session transient states are enabled, we * enable the event, else we disable it. */ - cds_list_for_each_entry(event, &session->events_head, node) { + cds_list_for_each_entry(event_priv, &session->events_head, node) { struct lttng_enabler_ref *enabler_ref; struct lttng_bytecode_runtime *runtime; int enabled = 0, has_enablers_without_bytecode = 0; /* Enable events */ cds_list_for_each_entry(enabler_ref, - &event->enablers_ref_head, node) { + &event_priv->enablers_ref_head, node) { if (enabler_ref->ref->enabled) { enabled = 1; break; @@ -1674,42 +1675,49 @@ void lttng_session_sync_event_enablers(struct lttng_session *session) * intesection of session and channel transient enable * states. */ - enabled = enabled && session->tstate && event->chan->tstate; + enabled = enabled && session->tstate && event_priv->pub->chan->tstate; - CMM_STORE_SHARED(event->enabled, enabled); + CMM_STORE_SHARED(event_priv->pub->enabled, enabled); /* * Sync tracepoint registration with event enabled * state. */ if (enabled) { - if (!event->registered) - register_event(event); + if (!event_priv->registered) + register_event(event_priv->pub); } else { - if (event->registered) - unregister_event(event); + if (event_priv->registered) + unregister_event(event_priv->pub); } /* Check if has enablers without bytecode enabled */ cds_list_for_each_entry(enabler_ref, - &event->enablers_ref_head, node) { + &event_priv->enablers_ref_head, node) { if (enabler_ref->ref->enabled && cds_list_empty(&enabler_ref->ref->filter_bytecode_head)) { has_enablers_without_bytecode = 1; break; } } - event->has_enablers_without_bytecode = + event_priv->pub->has_enablers_without_bytecode = has_enablers_without_bytecode; /* Enable filters */ cds_list_for_each_entry(runtime, - &event->filter_bytecode_runtime_head, node) { + &event_priv->pub->filter_bytecode_runtime_head, node) { lttng_bytecode_filter_sync_state(runtime); } } __tracepoint_probe_prune_release_queue(); } +/* Support for event notifier is introduced by probe provider major version 2. */ +static +bool lttng_ust_probe_supports_event_notifier(struct lttng_probe_desc *probe_desc) +{ + return probe_desc->major >= 2; +} + static void lttng_create_event_notifier_if_missing( struct lttng_event_notifier_enabler *event_notifier_enabler) @@ -1761,11 +1769,24 @@ void lttng_create_event_notifier_if_missing( if (found) continue; + /* Check that the probe supports event notifiers, else report the error. */ + if (!lttng_ust_probe_supports_event_notifier(probe_desc)) { + ERR("Probe \"%s\" contains event \"%s\" which matches an enabled event notifier, " + "but its version (%u.%u) is too old and does not implement event notifiers. " + "It needs to be recompiled against a newer version of LTTng-UST, otherwise " + "this event will not generate any notification.", + probe_desc->provider, + desc->name, + probe_desc->major, + probe_desc->minor); + continue; + } /* * We need to create a event_notifier for this event probe. */ ret = lttng_event_notifier_create(desc, event_notifier_enabler->user_token, + event_notifier_enabler->error_counter_index, event_notifier_group); if (ret) { DBG("Unable to create event_notifier %s, error %d\n", @@ -1942,7 +1963,7 @@ void lttng_ust_context_set_session_provider(const char *name, cds_list_for_each_entry(session, &sessions, node) { struct lttng_channel *chan; - struct lttng_event *event; + struct lttng_ust_event_private *event_priv; int ret; ret = lttng_ust_context_set_provider_rcu(&session->ctx, @@ -1955,8 +1976,8 @@ void lttng_ust_context_set_session_provider(const char *name, if (ret) abort(); } - cds_list_for_each_entry(event, &session->events_head, node) { - ret = lttng_ust_context_set_provider_rcu(&event->ctx, + cds_list_for_each_entry(event_priv, &session->events_head, node) { + ret = lttng_ust_context_set_provider_rcu(&event_priv->pub->ctx, name, get_size, record, get_value); if (ret) abort();