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);
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);
}
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);
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;
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);
}
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) {
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;
}
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;
}
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:
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);
/*
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;
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;
}
}
-/*
- * 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.
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;
}
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;
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);
}
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;
}
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;
}
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);
}
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.
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)
* 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:
_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);
}
}
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:
_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);
}
}
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)
projects / lttng-modules.git / blobdiff