X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=9f9e89471afb840b110fe7a4c4d7de0bcb2348ca;hb=33af697f72163d725389878666a4ce9dce42a442;hp=fe29870d09b65c2b2cba7289a4364a98567330f0;hpb=96c59af1110120208582f0ca4e90c4957b455f0c;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index fe29870d..9f9e8947 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -71,8 +71,7 @@ static void lttng_event_enabler_sync(struct lttng_event_enabler_common *event_en 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_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_unregister(struct lttng_kernel_event_common *event); static int _lttng_event_metadata_statedump(struct lttng_kernel_session *session, struct lttng_kernel_channel_buffer *chan, @@ -322,8 +321,8 @@ struct lttng_event_notifier_group *lttng_event_notifier_group_create(void) INIT_LIST_HEAD(&event_notifier_group->enablers_head); INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head); - for (i = 0; i < LTTNG_EVENT_NOTIFIER_HT_SIZE; i++) - INIT_HLIST_HEAD(&event_notifier_group->event_notifiers_ht.table[i]); + for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++) + INIT_HLIST_HEAD(&event_notifier_group->events_ht.table[i]); list_add(&event_notifier_group->node, &event_notifier_groups); @@ -360,16 +359,16 @@ void lttng_session_destroy(struct lttng_kernel_session *session) 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_recorder_unregister(event_recorder_priv->pub); + ret = _lttng_event_unregister(&event_recorder_priv->pub->parent); 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_channel(chan_priv->pub); + 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, @@ -410,12 +409,12 @@ 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, &event_notifier_group->event_notifiers_head, node) { - ret = _lttng_event_notifier_unregister(event_notifier_priv->pub); + ret = _lttng_event_unregister(&event_notifier_priv->pub->parent); WARN_ON(ret); } @@ -424,7 +423,8 @@ 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) @@ -578,47 +578,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; @@ -752,7 +765,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, @@ -967,7 +980,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l event_param->u.kprobe.symbol_name, event_param->u.kprobe.offset, event_param->u.kprobe.addr, - event_recorder); + &event_recorder->parent); if (ret) { ret = -EINVAL; goto register_error; @@ -1022,7 +1035,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l event_param->u.kretprobe.symbol_name, event_param->u.kretprobe.offset, event_param->u.kretprobe.addr, - event_recorder, event_recorder_return); + &event_recorder->parent, &event_recorder_return->parent); if (ret) { kmem_cache_free(event_recorder_private_cache, event_recorder_return_priv); kmem_cache_free(event_recorder_cache, event_recorder_return); @@ -1100,7 +1113,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l ret = lttng_uprobes_register_event(event_param->name, event_param->u.uprobe.fd, - event_recorder); + &event_recorder->parent); if (ret) goto register_error; ret = try_module_get(event_recorder->priv->parent.desc->owner); @@ -1177,8 +1190,8 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( goto type_error; } - head = utils_borrow_hash_table_bucket(event_notifier_group->event_notifiers_ht.table, - LTTNG_EVENT_NOTIFIER_HT_SIZE, event_name); + head = utils_borrow_hash_table_bucket(event_notifier_group->events_ht.table, + LTTNG_EVENT_HT_SIZE, event_name); lttng_hlist_for_each_entry(event_notifier_priv, head, hlist) { WARN_ON_ONCE(!event_notifier_priv->parent.desc); if (!strncmp(event_notifier_priv->parent.desc->event_name, event_name, @@ -1243,11 +1256,11 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( * registration. */ smp_wmb(); - ret = lttng_kprobes_register_event_notifier( + ret = lttng_kprobes_register_event(event_notifier_param->event.u.kprobe.symbol_name, event_notifier_param->event.u.kprobe.symbol_name, event_notifier_param->event.u.kprobe.offset, event_notifier_param->event.u.kprobe.addr, - event_notifier); + &event_notifier->parent); if (ret) { ret = -EINVAL; goto register_error; @@ -1307,10 +1320,9 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( */ smp_wmb(); - ret = lttng_uprobes_register_event_notifier( - event_notifier_param->event.name, + ret = lttng_uprobes_register_event(event_notifier_param->event.name, event_notifier_param->event.u.uprobe.fd, - event_notifier); + &event_notifier->parent); if (ret) goto register_error; ret = try_module_get(event_notifier->priv->parent.desc->owner); @@ -1425,34 +1437,43 @@ struct lttng_kernel_event_notifier *lttng_event_notifier_create( /* Only used for tracepoints for now. */ static -void register_event_recorder(struct lttng_kernel_event_recorder *event_recorder) +void register_event(struct lttng_kernel_event_common *event) { const struct lttng_kernel_event_desc *desc; int ret = -EINVAL; - if (event_recorder->priv->parent.registered) + if (event->priv->registered) return; - desc = event_recorder->priv->parent.desc; - switch (event_recorder->priv->parent.instrumentation) { + desc = event->priv->desc; + switch (event->priv->instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname, desc->tp_class->probe_callback, - event_recorder); + event); break; case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_enable_event_recorder(event_recorder); + ret = lttng_syscall_filter_enable_event(event); break; case LTTNG_KERNEL_ABI_KPROBE: lttng_fallthrough; case LTTNG_KERNEL_ABI_UPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_KRETPROBE: ret = 0; break; + case LTTNG_KERNEL_ABI_KRETPROBE: + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + ret = 0; + break; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + WARN_ON_ONCE(1); + break; + } + break; + case LTTNG_KERNEL_ABI_FUNCTION: lttng_fallthrough; case LTTNG_KERNEL_ABI_NOOP: @@ -1461,15 +1482,12 @@ void register_event_recorder(struct lttng_kernel_event_recorder *event_recorder) WARN_ON_ONCE(1); } if (!ret) - event_recorder->priv->parent.registered = 1; + event->priv->registered = 1; } -/* - * Only used internally at session destruction. - */ -int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_recorder) +int _lttng_event_unregister(struct lttng_kernel_event_common *event) { - struct lttng_kernel_event_common_private *event_priv = &event_recorder->priv->parent; + struct lttng_kernel_event_common_private *event_priv = event->priv; const struct lttng_kernel_event_desc *desc; int ret = -EINVAL; @@ -1481,29 +1499,43 @@ int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_r 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); break; case LTTNG_KERNEL_ABI_KPROBE: - lttng_kprobes_unregister_event(event_recorder); + lttng_kprobes_unregister_event(event); ret = 0; break; case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_kretprobes_unregister(event_recorder); - ret = 0; + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + lttng_kretprobes_unregister(event); + ret = 0; + break; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + WARN_ON_ONCE(1); + break; + } break; case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_disable_event_recorder(event_recorder); + ret = lttng_syscall_filter_disable_event(event); break; case LTTNG_KERNEL_ABI_NOOP: - ret = 0; + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + ret = 0; + break; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + WARN_ON_ONCE(1); + break; + } break; case LTTNG_KERNEL_ABI_UPROBE: - lttng_uprobes_unregister_event(event_recorder); + lttng_uprobes_unregister_event(event); ret = 0; break; @@ -1517,93 +1549,6 @@ int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_r return ret; } -/* Only used for tracepoints for now. */ -static -void register_event_notifier(struct lttng_kernel_event_notifier *event_notifier) -{ - const struct lttng_kernel_event_desc *desc; - int ret = -EINVAL; - - if (event_notifier->priv->parent.registered) - return; - - desc = event_notifier->priv->parent.desc; - switch (event_notifier->priv->parent.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname, - desc->tp_class->probe_callback, - event_notifier); - break; - - case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_enable_event_notifier(event_notifier); - break; - - case LTTNG_KERNEL_ABI_KPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_UPROBE: - ret = 0; - break; - - case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; - default: - WARN_ON_ONCE(1); - } - if (!ret) - event_notifier->priv->parent.registered = 1; -} - -static -int _lttng_event_notifier_unregister( - struct lttng_kernel_event_notifier *event_notifier) -{ - const struct lttng_kernel_event_desc *desc; - int ret = -EINVAL; - - if (!event_notifier->priv->parent.registered) - return 0; - - desc = event_notifier->priv->parent.desc; - switch (event_notifier->priv->parent.instrumentation) { - 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); - break; - - case LTTNG_KERNEL_ABI_KPROBE: - lttng_kprobes_unregister_event_notifier(event_notifier); - ret = 0; - break; - - case LTTNG_KERNEL_ABI_UPROBE: - lttng_uprobes_unregister_event_notifier(event_notifier); - ret = 0; - break; - - case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_disable_event_notifier(event_notifier); - break; - - case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; - default: - WARN_ON_ONCE(1); - } - if (!ret) - event_notifier->priv->parent.registered = 0; - return ret; -} - /* * Only used internally at session destruction. */ @@ -1632,12 +1577,12 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) case LTTNG_KERNEL_ABI_KPROBE: module_put(event_priv->desc->owner); - lttng_kprobes_destroy_event_private(event_recorder); + lttng_kprobes_destroy_event_private(&event_recorder->parent); break; case LTTNG_KERNEL_ABI_KRETPROBE: module_put(event_priv->desc->owner); - lttng_kretprobes_destroy_private(event_recorder); + lttng_kretprobes_destroy_private(&event_recorder->parent); break; case LTTNG_KERNEL_ABI_SYSCALL: @@ -1645,7 +1590,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) case LTTNG_KERNEL_ABI_UPROBE: module_put(event_priv->desc->owner); - lttng_uprobes_destroy_event_private(event_recorder); + lttng_uprobes_destroy_event_private(&event_recorder->parent); break; case LTTNG_KERNEL_ABI_FUNCTION: @@ -1672,7 +1617,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) case LTTNG_KERNEL_ABI_KPROBE: module_put(event_notifier->priv->parent.desc->owner); - lttng_kprobes_destroy_event_notifier_private(event_notifier); + lttng_kprobes_destroy_event_private(&event_notifier->parent); break; case LTTNG_KERNEL_ABI_SYSCALL: @@ -1680,7 +1625,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) case LTTNG_KERNEL_ABI_UPROBE: module_put(event_notifier->priv->parent.desc->owner); - lttng_uprobes_destroy_event_notifier_private(event_notifier); + lttng_uprobes_destroy_event_private(&event_notifier->parent); break; case LTTNG_KERNEL_ABI_KRETPROBE: @@ -2198,8 +2143,8 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi * Check if already created. */ head = utils_borrow_hash_table_bucket( - event_notifier_group->event_notifiers_ht.table, - LTTNG_EVENT_NOTIFIER_HT_SIZE, desc->event_name); + event_notifier_group->events_ht.table, + LTTNG_EVENT_HT_SIZE, desc->event_name); lttng_hlist_for_each_entry(event_notifier_priv, head, hlist) { if (event_notifier_priv->parent.desc == desc && event_notifier_priv->parent.user_token == event_notifier_enabler->parent.user_token) @@ -2225,7 +2170,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi } static -void lttng_create_syscall_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) +void lttng_create_syscall_event_if_missing(struct lttng_event_enabler_common *event_enabler) { int ret; @@ -2233,17 +2178,6 @@ void lttng_create_syscall_event_if_missing(struct lttng_event_recorder_enabler * WARN_ON_ONCE(ret); } -static -void lttng_create_syscall_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler) -{ - int ret; - - ret = lttng_syscalls_register_event_notifier(event_notifier_enabler); - WARN_ON_ONCE(ret); - ret = lttng_syscalls_create_matching_event_notifiers(event_notifier_enabler); - WARN_ON_ONCE(ret); -} - /* * Create struct lttng_kernel_event_recorder if it is missing and present in the list of * tracepoint probes. @@ -2258,7 +2192,7 @@ void lttng_create_event_if_missing(struct lttng_event_recorder_enabler *event_en break; case LTTNG_KERNEL_ABI_SYSCALL: - lttng_create_syscall_event_if_missing(event_enabler); + lttng_create_syscall_event_if_missing(&event_enabler->parent); break; default: @@ -2344,7 +2278,7 @@ void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler break; case LTTNG_KERNEL_ABI_SYSCALL: - lttng_create_syscall_event_notifier_if_missing(event_notifier_enabler); + lttng_create_syscall_event_if_missing(&event_notifier_enabler->parent); break; default: @@ -2774,9 +2708,9 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) * state. */ if (enabled) { - register_event_recorder(event_recorder); + register_event(&event_recorder->parent); } else { - _lttng_event_recorder_unregister(event_recorder); + _lttng_event_unregister(&event_recorder->parent); } /* Check if has enablers without bytecode enabled */ @@ -2864,10 +2798,10 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group */ if (enabled) { if (!event_notifier_priv->parent.registered) - register_event_notifier(event_notifier); + register_event(&event_notifier->parent); } else { if (event_notifier_priv->parent.registered) - _lttng_event_notifier_unregister(event_notifier); + _lttng_event_unregister(&event_notifier->parent); } /* Check if has enablers without bytecode enabled */