X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=src%2Flttng-events.c;h=ebeda98668ddecc9ba97b3a21a66b950dd88d6c2;hb=14a15badd515c2f691512ac7461935127a30bb9d;hp=f864eaba57db0d881f916eba7a49b6254b3ca6fe;hpb=7b25ab0ebebea6eef31b687292db60eab4c6babc;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index f864eaba..ebeda986 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -66,13 +66,12 @@ static struct kmem_cache *event_notifier_private_cache; static void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session *session); static void lttng_session_sync_event_enablers(struct lttng_kernel_session *session); -static void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler *event_notifier_enabler); static void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group); static void lttng_event_enabler_sync(struct lttng_event_enabler_common *event_enabler); static void _lttng_event_destroy(struct lttng_kernel_event_common *event); static void _lttng_channel_destroy(struct lttng_kernel_channel_buffer *chan); -static int _lttng_event_unregister(struct lttng_kernel_event_recorder *event); +static int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event); static int _lttng_event_notifier_unregister(struct lttng_kernel_event_notifier *event_notifier); static int _lttng_event_metadata_statedump(struct lttng_kernel_session *session, @@ -355,27 +354,27 @@ 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_enabler, *tmp_event_enabler; + struct lttng_event_recorder_enabler *event_recorder_enabler, *tmp_event_recorder_enabler; int ret; mutex_lock(&sessions_mutex); WRITE_ONCE(session->active, 0); list_for_each_entry(chan_priv, &session->priv->chan, node) { - ret = lttng_syscalls_unregister_channel(chan_priv->pub); + 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) { - ret = _lttng_event_unregister(event_recorder_priv->pub); + ret = _lttng_event_recorder_unregister(event_recorder_priv->pub); WARN_ON(ret); } synchronize_trace(); /* Wait for in-flight events to complete */ list_for_each_entry(chan_priv, &session->priv->chan, node) { - ret = lttng_syscalls_destroy_event(chan_priv->pub); + ret = lttng_syscalls_destroy_syscall_table(&chan_priv->parent.syscall_table); WARN_ON(ret); } - list_for_each_entry_safe(event_enabler, tmp_event_enabler, + list_for_each_entry_safe(event_recorder_enabler, tmp_event_recorder_enabler, &session->priv->enablers_head, node) - lttng_event_enabler_destroy(event_enabler); + lttng_event_enabler_destroy(&event_recorder_enabler->parent); list_for_each_entry_safe(event_recorder_priv, tmpevent_recorder_priv, &session->priv->events, node) _lttng_event_destroy(&event_recorder_priv->pub->parent); list_for_each_entry_safe(chan_priv, tmpchan_priv, &session->priv->chan, node) { @@ -411,7 +410,7 @@ void lttng_event_notifier_group_destroy( mutex_lock(&sessions_mutex); - ret = lttng_syscalls_unregister_event_notifier_group(event_notifier_group); + ret = lttng_syscalls_unregister_syscall_table(&event_notifier_group->syscall_table); WARN_ON(ret); list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv, @@ -425,11 +424,12 @@ void lttng_event_notifier_group_destroy( irq_work_sync(&event_notifier_group->wakeup_pending); - kfree(event_notifier_group->syscall_table.sc_filter); + 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, &event_notifier_group->enablers_head, node) - lttng_event_notifier_enabler_destroy(event_notifier_enabler); + lttng_event_enabler_destroy(&event_notifier_enabler->parent); list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv, &event_notifier_group->event_notifiers_head, node) @@ -579,47 +579,60 @@ end: return ret; } -int lttng_channel_enable(struct lttng_kernel_channel_buffer *channel) +static +bool is_channel_buffer_metadata(struct lttng_kernel_channel_common *channel) +{ + struct lttng_kernel_channel_buffer *chan_buf; + + if (channel->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER) + return false; + chan_buf = container_of(channel, struct lttng_kernel_channel_buffer, parent); + if (chan_buf->priv->channel_type == METADATA_CHANNEL) + return true; + return false; +} + +int lttng_channel_enable(struct lttng_kernel_channel_common *channel) { int ret = 0; mutex_lock(&sessions_mutex); - if (channel->priv->channel_type == METADATA_CHANNEL) { + if (is_channel_buffer_metadata(channel)) { ret = -EPERM; goto end; } - if (channel->parent.enabled) { + if (channel->enabled) { ret = -EEXIST; goto end; } /* Set transient enabler state to "enabled" */ - channel->priv->parent.tstate = 1; - lttng_session_sync_event_enablers(channel->parent.session); + channel->priv->tstate = 1; + lttng_session_sync_event_enablers(channel->session); /* Set atomically the state to "enabled" */ - WRITE_ONCE(channel->parent.enabled, 1); + WRITE_ONCE(channel->enabled, 1); end: mutex_unlock(&sessions_mutex); return ret; } -int lttng_channel_disable(struct lttng_kernel_channel_buffer *channel) +int lttng_channel_disable(struct lttng_kernel_channel_common *channel) { int ret = 0; mutex_lock(&sessions_mutex); - if (channel->priv->channel_type == METADATA_CHANNEL) { + if (is_channel_buffer_metadata(channel)) { ret = -EPERM; goto end; } - if (!channel->parent.enabled) { + if (!channel->enabled) { ret = -EEXIST; goto end; } /* Set atomically the state to "disabled" */ - WRITE_ONCE(channel->parent.enabled, 0); + WRITE_ONCE(channel->enabled, 0); /* Set transient enabler state to "enabled" */ - channel->priv->parent.tstate = 0; - lttng_session_sync_event_enablers(channel->parent.session); + channel->priv->tstate = 0; + lttng_session_sync_event_enablers(channel->session); end: mutex_unlock(&sessions_mutex); return ret; @@ -753,7 +766,7 @@ end: return ret; } -struct lttng_kernel_channel_buffer *lttng_channel_create(struct lttng_kernel_session *session, +struct lttng_kernel_channel_buffer *lttng_channel_buffer_create(struct lttng_kernel_session *session, const char *transport_name, void *buf_addr, size_t subbuf_size, size_t num_subbuf, @@ -1426,7 +1439,7 @@ struct lttng_kernel_event_notifier *lttng_event_notifier_create( /* Only used for tracepoints for now. */ static -void register_event(struct lttng_kernel_event_recorder *event_recorder) +void register_event_recorder(struct lttng_kernel_event_recorder *event_recorder) { const struct lttng_kernel_event_desc *desc; int ret = -EINVAL; @@ -1439,11 +1452,11 @@ void register_event(struct lttng_kernel_event_recorder *event_recorder) case LTTNG_KERNEL_ABI_TRACEPOINT: ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname, desc->tp_class->probe_callback, - event_recorder); + &event_recorder->parent); break; case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_enable_event(event_recorder->chan, event_recorder); + ret = lttng_syscall_filter_enable_event_recorder(event_recorder); break; case LTTNG_KERNEL_ABI_KPROBE: @@ -1468,7 +1481,7 @@ void register_event(struct lttng_kernel_event_recorder *event_recorder) /* * Only used internally at session destruction. */ -int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder) +int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_recorder) { struct lttng_kernel_event_common_private *event_priv = &event_recorder->priv->parent; const struct lttng_kernel_event_desc *desc; @@ -1482,7 +1495,7 @@ int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder) case LTTNG_KERNEL_ABI_TRACEPOINT: ret = lttng_wrapper_tracepoint_probe_unregister(event_priv->desc->event_kname, event_priv->desc->tp_class->probe_callback, - event_recorder); + &event_recorder->parent); break; case LTTNG_KERNEL_ABI_KPROBE: @@ -1496,7 +1509,7 @@ int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder) break; case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_disable_event(event_recorder->chan, event_recorder); + ret = lttng_syscall_filter_disable_event_recorder(event_recorder); break; case LTTNG_KERNEL_ABI_NOOP: @@ -1533,7 +1546,7 @@ void register_event_notifier(struct lttng_kernel_event_notifier *event_notifier) case LTTNG_KERNEL_ABI_TRACEPOINT: ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname, desc->tp_class->probe_callback, - event_notifier); + &event_notifier->parent); break; case LTTNG_KERNEL_ABI_SYSCALL: @@ -1574,7 +1587,7 @@ int _lttng_event_notifier_unregister( case LTTNG_KERNEL_ABI_TRACEPOINT: ret = lttng_wrapper_tracepoint_probe_unregister(event_notifier->priv->parent.desc->event_kname, event_notifier->priv->parent.desc->tp_class->probe_callback, - event_notifier); + &event_notifier->parent); break; case LTTNG_KERNEL_ABI_KPROBE: @@ -2593,13 +2606,33 @@ void lttng_enabler_destroy(struct lttng_event_enabler_common *enabler) } } -void lttng_event_enabler_destroy(struct lttng_event_recorder_enabler *event_enabler) +void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enabler) { - lttng_enabler_destroy(lttng_event_recorder_enabler_as_enabler(event_enabler)); + 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); - if (event_enabler->published) - list_del(&event_enabler->node); - kfree(event_enabler); + lttng_enabler_destroy(event_enabler); + if (event_recorder_enabler->published) + list_del(&event_recorder_enabler->node); + kfree(event_recorder_enabler); + 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); + + list_del(&event_notifier_enabler->node); + lttng_enabler_destroy(event_enabler); + kfree(event_notifier_enabler); + break; + } + default: + WARN_ON_ONCE(1); + } } struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create( @@ -2699,20 +2732,6 @@ end: return ret; } -static -void lttng_event_notifier_enabler_destroy( - struct lttng_event_notifier_enabler *event_notifier_enabler) -{ - if (!event_notifier_enabler) { - return; - } - - list_del(&event_notifier_enabler->node); - - lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)); - kfree(event_notifier_enabler); -} - /* * lttng_session_sync_event_enablers should be called just before starting a * session. @@ -2769,9 +2788,9 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) * state. */ if (enabled) { - register_event(event_recorder); + register_event_recorder(event_recorder); } else { - _lttng_event_unregister(event_recorder); + _lttng_event_recorder_unregister(event_recorder); } /* Check if has enablers without bytecode enabled */