X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=6d3e3f1a2c64089e4a5761e13088da07e747e49a;hb=09710b830767f6cc69fc68ea7e1903a1122d1045;hp=181fdefaef30a0a02fa3cf51c157d25ef1e8af2f;hpb=8839618b7286bd8d3da59ed3fe3831851ace3454;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index 181fdefa..6d3e3f1a 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -353,7 +353,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session) struct lttng_kernel_channel_buffer_private *chan_priv, *tmpchan_priv; struct lttng_kernel_event_recorder_private *event_recorder_priv, *tmpevent_recorder_priv; struct lttng_metadata_stream *metadata_stream; - struct lttng_event_recorder_enabler *event_recorder_enabler, *tmp_event_recorder_enabler; + struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler; int ret; mutex_lock(&sessions_mutex); @@ -362,7 +362,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session) ret = lttng_syscalls_unregister_syscall_table(&chan_priv->parent.syscall_table); WARN_ON(ret); } - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { ret = _lttng_event_unregister(&event_recorder_priv->pub->parent); WARN_ON(ret); } @@ -371,10 +371,9 @@ void lttng_session_destroy(struct lttng_kernel_session *session) ret = lttng_syscalls_destroy_syscall_table(&chan_priv->parent.syscall_table); WARN_ON(ret); } - list_for_each_entry_safe(event_recorder_enabler, tmp_event_recorder_enabler, - &session->priv->enablers_head, node) - lttng_event_enabler_destroy(&event_recorder_enabler->parent); - list_for_each_entry_safe(event_recorder_priv, tmpevent_recorder_priv, &session->priv->events, node) + list_for_each_entry_safe(event_enabler, tmp_event_enabler, &session->priv->enablers_head, node) + lttng_event_enabler_destroy(event_enabler); + list_for_each_entry_safe(event_recorder_priv, tmpevent_recorder_priv, &session->priv->events, parent.node) _lttng_event_destroy(&event_recorder_priv->pub->parent); list_for_each_entry_safe(chan_priv, tmpchan_priv, &session->priv->chan, node) { BUG_ON(chan_priv->channel_type == METADATA_CHANNEL); @@ -400,7 +399,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session) void lttng_event_notifier_group_destroy( struct lttng_event_notifier_group *event_notifier_group) { - struct lttng_event_notifier_enabler *event_notifier_enabler, *tmp_event_notifier_enabler; + struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler; struct lttng_kernel_event_notifier_private *event_notifier_priv, *tmpevent_notifier_priv; int ret; @@ -413,7 +412,7 @@ void lttng_event_notifier_group_destroy( WARN_ON(ret); list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv, - &event_notifier_group->event_notifiers_head, node) { + &event_notifier_group->event_notifiers_head, parent.node) { ret = _lttng_event_unregister(&event_notifier_priv->pub->parent); WARN_ON(ret); } @@ -426,12 +425,12 @@ void lttng_event_notifier_group_destroy( ret = lttng_syscalls_destroy_syscall_table(&event_notifier_group->syscall_table); WARN_ON(ret); - list_for_each_entry_safe(event_notifier_enabler, tmp_event_notifier_enabler, + list_for_each_entry_safe(event_enabler, tmp_event_enabler, &event_notifier_group->enablers_head, node) - lttng_event_enabler_destroy(&event_notifier_enabler->parent); + lttng_event_enabler_destroy(event_enabler); list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv, - &event_notifier_group->event_notifiers_head, node) + &event_notifier_group->event_notifiers_head, parent.node) _lttng_event_destroy(&event_notifier_priv->pub->parent); if (event_notifier_group->error_counter) { @@ -567,7 +566,7 @@ int lttng_session_metadata_regenerate(struct lttng_kernel_session *session) chan_priv->metadata_dumped = 0; } - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { event_recorder_priv->metadata_dumped = 0; } @@ -1060,7 +1059,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l module_put(event_recorder->priv->parent.desc->owner); goto statedump_error; } - list_add(&event_recorder_return->priv->node, &chan->parent.session->priv->events); + list_add(&event_recorder_return->priv->parent.node, &chan->parent.session->priv->events); break; } @@ -1138,7 +1137,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l goto statedump_error; } hlist_add_head(&event_recorder->priv->parent.hlist_node, head); - list_add(&event_recorder->priv->node, &chan->parent.session->priv->events); + list_add(&event_recorder->priv->parent.node, &chan->parent.session->priv->events); return event_recorder; statedump_error: @@ -1348,7 +1347,7 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l goto register_error; } - list_add(&event_notifier->priv->node, &event_notifier_group->event_notifiers_head); + list_add(&event_notifier->priv->parent.node, &event_notifier_group->event_notifiers_head); hlist_add_head(&event_notifier->priv->parent.hlist_node, head); /* @@ -1623,7 +1622,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) default: WARN_ON_ONCE(1); } - list_del(&event_recorder->priv->node); + list_del(&event_recorder->priv->parent.node); kmem_cache_free(event_recorder_private_cache, event_recorder->priv); kmem_cache_free(event_recorder_cache, event_recorder); break; @@ -1660,7 +1659,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) default: WARN_ON_ONCE(1); } - list_del(&event_notifier->priv->node); + list_del(&event_notifier->priv->parent.node); kmem_cache_free(event_notifier_private_cache, event_notifier->priv); kmem_cache_free(event_notifier_cache, event_notifier); break; @@ -2222,109 +2221,66 @@ void lttng_create_event_if_missing(struct lttng_event_enabler_common *event_enab } } -/* - * Create events associated with an event_enabler (if not already present), - * and add backward reference from the event to the enabler. - * Should be called with sessions mutex held. - */ static -int lttng_event_enabler_ref_events(struct lttng_event_recorder_enabler *event_enabler) +void lttng_event_enabler_init_event_filter(struct lttng_event_enabler_common *event_enabler, + struct lttng_kernel_event_common *event) { - struct lttng_kernel_channel_buffer *chan = event_enabler->chan; - struct lttng_kernel_session *session = event_enabler->chan->parent.session; - struct lttng_event_enabler_common *base_enabler = lttng_event_recorder_enabler_as_enabler(event_enabler); - struct lttng_kernel_event_recorder_private *event_recorder_priv; - - if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_ABI_SYSCALL && - base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL && - base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME && - !strcmp(base_enabler->event_param.name, "*")) { - int enabled = base_enabler->enabled; - enum lttng_kernel_abi_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit; + /* Link filter bytecodes if not linked yet. */ + lttng_enabler_link_bytecode(event->priv->desc, lttng_static_ctx, + &event->priv->filter_bytecode_runtime_head, &event_enabler->filter_bytecode_head); +} - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - WRITE_ONCE(chan->priv->parent.syscall_table.syscall_all_entry, enabled); +static +void lttng_event_enabler_init_event_capture(struct lttng_event_enabler_common *event_enabler, + struct lttng_kernel_event_common *event) +{ + switch (event_enabler->enabler_type) { + case LTTNG_EVENT_ENABLER_TYPE_RECORDER: + break; + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + { + struct lttng_event_notifier_enabler *event_notifier_enabler = + container_of(event_enabler, struct lttng_event_notifier_enabler, parent); + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - WRITE_ONCE(chan->priv->parent.syscall_table.syscall_all_exit, enabled); + /* Link capture bytecodes if not linked yet. */ + lttng_enabler_link_bytecode(event->priv->desc, + lttng_static_ctx, &event_notifier->priv->capture_bytecode_runtime_head, + &event_notifier_enabler->capture_bytecode_head); + event_notifier->priv->num_captures = event_notifier_enabler->num_captures; + break; } - - /* First ensure that probe events are created for this enabler. */ - lttng_create_event_if_missing(&event_enabler->parent); - - /* For each event matching event_enabler in session event list. */ - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { - struct lttng_kernel_event_recorder *event_recorder = event_recorder_priv->pub; - struct lttng_enabler_ref *enabler_ref; - - if (!lttng_event_enabler_match_event(&event_enabler->parent, &event_recorder->parent)) - continue; - enabler_ref = lttng_enabler_ref(&event_recorder_priv->parent.enablers_ref_head, - lttng_event_recorder_enabler_as_enabler(event_enabler)); - if (!enabler_ref) { - /* - * If no backward ref, create it. - * Add backward ref from event to event_enabler. - */ - enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL); - if (!enabler_ref) - return -ENOMEM; - enabler_ref->ref = lttng_event_recorder_enabler_as_enabler(event_enabler); - list_add(&enabler_ref->node, - &event_recorder_priv->parent.enablers_ref_head); - } - - /* - * Link filter bytecodes if not linked yet. - */ - lttng_enabler_link_bytecode(event_recorder_priv->parent.desc, - lttng_static_ctx, - &event_recorder_priv->parent.filter_bytecode_runtime_head, - <tng_event_recorder_enabler_as_enabler(event_enabler)->filter_bytecode_head); + default: + WARN_ON_ONCE(1); } - return 0; } /* - * Create event_notifiers associated with a event_notifier enabler (if not already present). + * Create events associated with an event_enabler (if not already present), + * and add backward reference from the event to the enabler. + * Should be called with sessions mutex held. */ static -int lttng_event_notifier_enabler_ref_event_notifiers( - struct lttng_event_notifier_enabler *event_notifier_enabler) +int lttng_event_enabler_ref_events(struct lttng_event_enabler_common *event_enabler) { - struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group; - struct lttng_event_enabler_common *base_enabler = lttng_event_notifier_enabler_as_enabler(event_notifier_enabler); - struct lttng_kernel_event_notifier_private *event_notifier_priv; - - if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_ABI_SYSCALL && - base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL && - base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME && - !strcmp(base_enabler->event_param.name, "*")) { - - int enabled = base_enabler->enabled; - enum lttng_kernel_abi_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit; - - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - WRITE_ONCE(event_notifier_group->syscall_table.syscall_all_entry, enabled); - - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - WRITE_ONCE(event_notifier_group->syscall_table.syscall_all_exit, enabled); + struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler); + struct lttng_kernel_event_common_private *event_priv; - } + lttng_syscall_table_set_wildcard_all(event_enabler); - /* First ensure that probe event_notifiers are created for this enabler. */ - lttng_create_event_if_missing(&event_notifier_enabler->parent); + /* First ensure that probe events are created for this enabler. */ + lttng_create_event_if_missing(event_enabler); - /* Link the created event_notifier with its associated enabler. */ - list_for_each_entry(event_notifier_priv, &event_notifier_group->event_notifiers_head, node) { - struct lttng_kernel_event_notifier *event_notifier = event_notifier_priv->pub; + /* Link the created event with its associated enabler. */ + list_for_each_entry(event_priv, event_list_head, node) { + struct lttng_kernel_event_common *event = event_priv->pub; struct lttng_enabler_ref *enabler_ref; - if (!lttng_event_enabler_match_event(&event_notifier_enabler->parent, &event_notifier->parent)) + if (!lttng_event_enabler_match_event(event_enabler, event)) continue; - enabler_ref = lttng_enabler_ref(&event_notifier_priv->parent.enablers_ref_head, - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)); + enabler_ref = lttng_enabler_ref(&event_priv->enablers_ref_head, event_enabler); if (!enabler_ref) { /* * If no backward ref, create it. @@ -2334,25 +2290,12 @@ int lttng_event_notifier_enabler_ref_event_notifiers( if (!enabler_ref) return -ENOMEM; - enabler_ref->ref = lttng_event_notifier_enabler_as_enabler( - event_notifier_enabler); - list_add(&enabler_ref->node, - &event_notifier_priv->parent.enablers_ref_head); + enabler_ref->ref = event_enabler; + list_add(&enabler_ref->node, &event_priv->enablers_ref_head); } - /* - * Link filter bytecodes if not linked yet. - */ - lttng_enabler_link_bytecode(event_notifier_priv->parent.desc, - lttng_static_ctx, &event_notifier_priv->parent.filter_bytecode_runtime_head, - <tng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head); - - /* Link capture bytecodes if not linked yet. */ - lttng_enabler_link_bytecode(event_notifier_priv->parent.desc, - lttng_static_ctx, &event_notifier_priv->capture_bytecode_runtime_head, - &event_notifier_enabler->capture_bytecode_head); - - event_notifier_priv->num_captures = event_notifier_enabler->num_captures; + lttng_event_enabler_init_event_filter(event_enabler, event); + lttng_event_enabler_init_event_capture(event_enabler, event); } return 0; } @@ -2374,11 +2317,10 @@ int lttng_fix_pending_events(void) static bool lttng_event_notifier_group_has_active_event_notifiers( struct lttng_event_notifier_group *event_notifier_group) { - struct lttng_event_notifier_enabler *event_notifier_enabler; + struct lttng_event_enabler_common *event_enabler; - list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, - node) { - if (event_notifier_enabler->parent.enabled) + list_for_each_entry(event_enabler, &event_notifier_group->enablers_head, node) { + if (event_enabler->enabled) return true; } return false; @@ -2429,8 +2371,8 @@ void lttng_event_enabler_session_add(struct lttng_kernel_session *session, struct lttng_event_recorder_enabler *event_enabler) { mutex_lock(&sessions_mutex); - list_add(&event_enabler->node, &session->priv->enablers_head); - event_enabler->published = true; + list_add(&event_enabler->parent.node, &session->priv->enablers_head); + event_enabler->parent.published = true; lttng_session_lazy_sync_event_enablers(session); mutex_unlock(&sessions_mutex); } @@ -2526,15 +2468,16 @@ void lttng_enabler_destroy(struct lttng_event_enabler_common *enabler) void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enabler) { + lttng_enabler_destroy(event_enabler); + if (event_enabler->published) + list_del(&event_enabler->node); + switch (event_enabler->enabler_type) { case LTTNG_EVENT_ENABLER_TYPE_RECORDER: { struct lttng_event_recorder_enabler *event_recorder_enabler = container_of(event_enabler, struct lttng_event_recorder_enabler, parent); - lttng_enabler_destroy(event_enabler); - if (event_recorder_enabler->published) - list_del(&event_recorder_enabler->node); kfree(event_recorder_enabler); break; } @@ -2543,9 +2486,6 @@ void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enable struct lttng_event_notifier_enabler *event_notifier_enabler = container_of(event_enabler, struct lttng_event_notifier_enabler, parent); - lttng_enabler_destroy(event_enabler); - if (event_notifier_enabler->published) - list_del(&event_notifier_enabler->node); kfree(event_notifier_enabler); break; } @@ -2586,8 +2526,8 @@ void lttng_event_notifier_enabler_group_add(struct lttng_event_notifier_group *e struct lttng_event_notifier_enabler *event_notifier_enabler) { mutex_lock(&sessions_mutex); - list_add(&event_notifier_enabler->node, &event_notifier_enabler->group->enablers_head); - event_notifier_enabler->published = true; + list_add(&event_notifier_enabler->parent.node, &event_notifier_enabler->group->enablers_head); + event_notifier_enabler->parent.published = true; lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); mutex_unlock(&sessions_mutex); } @@ -2654,6 +2594,57 @@ end: return ret; } +static +void lttng_event_sync_filter_state(struct lttng_kernel_event_common *event) +{ + int has_enablers_without_filter_bytecode = 0, nr_filters = 0; + struct lttng_kernel_bytecode_runtime *runtime; + struct lttng_enabler_ref *enabler_ref; + + /* Check if has enablers without bytecode enabled */ + list_for_each_entry(enabler_ref, &event->priv->enablers_ref_head, node) { + if (enabler_ref->ref->enabled + && list_empty(&enabler_ref->ref->filter_bytecode_head)) { + has_enablers_without_filter_bytecode = 1; + break; + } + } + event->priv->has_enablers_without_filter_bytecode = has_enablers_without_filter_bytecode; + + /* Enable filters */ + list_for_each_entry(runtime, &event->priv->filter_bytecode_runtime_head, node) { + lttng_bytecode_sync_state(runtime); + nr_filters++; + } + WRITE_ONCE(event->eval_filter, !(has_enablers_without_filter_bytecode || !nr_filters)); +} + +static +void lttng_event_sync_capture_state(struct lttng_kernel_event_common *event) +{ + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + break; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + { + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + struct lttng_kernel_bytecode_runtime *runtime; + int nr_captures = 0; + + /* Enable captures */ + list_for_each_entry(runtime, &event_notifier->priv->capture_bytecode_runtime_head, node) { + lttng_bytecode_sync_state(runtime); + nr_captures++; + } + WRITE_ONCE(event_notifier->eval_capture, !!nr_captures); + break; + } + default: + WARN_ON_ONCE(1); + } +} + /* * lttng_session_sync_event_enablers should be called just before starting a * session. @@ -2662,7 +2653,7 @@ end: static void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) { - struct lttng_event_recorder_enabler *event_enabler; + struct lttng_event_enabler_common *event_enabler; struct lttng_kernel_event_recorder_private *event_recorder_priv; list_for_each_entry(event_enabler, &session->priv->enablers_head, node) @@ -2672,12 +2663,10 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) * and its channel and session transient states are enabled, we * enable the event, else we disable it. */ - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { struct lttng_kernel_event_recorder *event_recorder = event_recorder_priv->pub; struct lttng_enabler_ref *enabler_ref; - struct lttng_kernel_bytecode_runtime *runtime; - int enabled = 0, has_enablers_without_filter_bytecode = 0; - int nr_filters = 0; + int enabled = 0; switch (event_recorder_priv->parent.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: @@ -2715,26 +2704,7 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) _lttng_event_unregister(&event_recorder->parent); } - /* Check if has enablers without bytecode enabled */ - list_for_each_entry(enabler_ref, - &event_recorder_priv->parent.enablers_ref_head, node) { - if (enabler_ref->ref->enabled - && list_empty(&enabler_ref->ref->filter_bytecode_head)) { - has_enablers_without_filter_bytecode = 1; - break; - } - } - event_recorder_priv->parent.has_enablers_without_filter_bytecode = - has_enablers_without_filter_bytecode; - - /* Enable filters */ - list_for_each_entry(runtime, - &event_recorder_priv->parent.filter_bytecode_runtime_head, node) { - lttng_bytecode_sync_state(runtime); - nr_filters++; - } - WRITE_ONCE(event_recorder_priv->parent.pub->eval_filter, - !(has_enablers_without_filter_bytecode || !nr_filters)); + lttng_event_sync_filter_state(&event_recorder_priv->pub->parent); } } @@ -2757,22 +2727,20 @@ void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session *session static void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group) { - struct lttng_event_notifier_enabler *event_notifier_enabler; + struct lttng_event_enabler_common *event_enabler; struct lttng_kernel_event_notifier_private *event_notifier_priv; - list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, node) - lttng_event_notifier_enabler_ref_event_notifiers(event_notifier_enabler); + list_for_each_entry(event_enabler, &event_notifier_group->enablers_head, node) + lttng_event_enabler_ref_events(event_enabler); /* * For each event_notifier, if at least one of its enablers is enabled, * we enable the event_notifier, else we disable it. */ - list_for_each_entry(event_notifier_priv, &event_notifier_group->event_notifiers_head, node) { + list_for_each_entry(event_notifier_priv, &event_notifier_group->event_notifiers_head, parent.node) { struct lttng_kernel_event_notifier *event_notifier = event_notifier_priv->pub; struct lttng_enabler_ref *enabler_ref; - struct lttng_kernel_bytecode_runtime *runtime; - int enabled = 0, has_enablers_without_filter_bytecode = 0; - int nr_filters = 0, nr_captures = 0; + int enabled = 0; switch (event_notifier_priv->parent.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: @@ -2806,34 +2774,8 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group _lttng_event_unregister(&event_notifier->parent); } - /* Check if has enablers without bytecode enabled */ - list_for_each_entry(enabler_ref, - &event_notifier_priv->parent.enablers_ref_head, node) { - if (enabler_ref->ref->enabled - && list_empty(&enabler_ref->ref->filter_bytecode_head)) { - has_enablers_without_filter_bytecode = 1; - break; - } - } - event_notifier_priv->parent.has_enablers_without_filter_bytecode = - has_enablers_without_filter_bytecode; - - /* Enable filters */ - list_for_each_entry(runtime, - &event_notifier_priv->parent.filter_bytecode_runtime_head, node) { - lttng_bytecode_sync_state(runtime); - nr_filters++; - } - WRITE_ONCE(event_notifier_priv->parent.pub->eval_filter, - !(has_enablers_without_filter_bytecode || !nr_filters)); - - /* Enable captures */ - list_for_each_entry(runtime, - &event_notifier_priv->capture_bytecode_runtime_head, node) { - lttng_bytecode_sync_state(runtime); - nr_captures++; - } - WRITE_ONCE(event_notifier->eval_capture, !!nr_captures); + lttng_event_sync_filter_state(&event_notifier_priv->pub->parent); + lttng_event_sync_capture_state(&event_notifier_priv->pub->parent); } } @@ -4088,7 +4030,7 @@ skip_session: goto end; } - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { ret = _lttng_event_metadata_statedump(session, event_recorder_priv->pub->chan, event_recorder_priv->pub); if (ret)