X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=039b43e6ffb21f82c9dc864a5c89652aba200a93;hb=0def91708e136463a7e19e322932844e596a02db;hp=af20bfccd117473051a26f8b6e66629c4b13d6f0;hpb=c1551e578e84be1c2b51f3ec6da25845277f9037;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index af20bfcc..039b43e6 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -28,6 +28,7 @@ #include #include +#include #include #include /* for wrapper_vmalloc_sync_mappings() */ #include @@ -65,14 +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_enabler_destroy(struct lttng_event_enabler *event_enabler); -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_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, @@ -93,7 +92,8 @@ int _lttng_field_statedump(struct lttng_kernel_session *session, void synchronize_trace(void) { -#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0)) +#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) || \ + LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0)) synchronize_rcu(); #else synchronize_sched(); @@ -321,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); @@ -353,27 +353,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_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_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_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) { @@ -409,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); } @@ -423,11 +423,12 @@ void lttng_event_notifier_group_destroy( irq_work_sync(&event_notifier_group->wakeup_pending); - kfree(event_notifier_group->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) @@ -577,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; @@ -658,12 +672,14 @@ int lttng_event_enable(struct lttng_kernel_event_common *event) goto end; } switch (event->priv->instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: /* Fall-through */ + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; case LTTNG_KERNEL_ABI_SYSCALL: ret = -EINVAL; break; - case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */ + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; case LTTNG_KERNEL_ABI_UPROBE: WRITE_ONCE(event->enabled, 1); break; @@ -672,8 +688,10 @@ int lttng_event_enable(struct lttng_kernel_event_common *event) ret = lttng_kretprobes_event_enable_state(event, 1); break; - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: WARN_ON_ONCE(1); ret = -EINVAL; @@ -718,12 +736,14 @@ int lttng_event_disable(struct lttng_kernel_event_common *event) goto end; } switch (event->priv->instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: /* Fall-through */ + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; case LTTNG_KERNEL_ABI_SYSCALL: ret = -EINVAL; break; - case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */ + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; case LTTNG_KERNEL_ABI_UPROBE: WRITE_ONCE(event->enabled, 0); break; @@ -732,8 +752,10 @@ int lttng_event_disable(struct lttng_kernel_event_common *event) ret = lttng_kretprobes_event_enable_state(event, 0); break; - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: WARN_ON_ONCE(1); ret = -EINVAL; @@ -743,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, @@ -850,14 +872,16 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream) * Supports event creation while tracing session is active. * Needs to be called with sessions mutex held. */ -struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_kernel_channel_buffer *chan, - struct lttng_kernel_abi_event *event_param, - const struct lttng_kernel_event_desc *event_desc, - enum lttng_kernel_abi_instrumentation itype) +struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_event_recorder_enabler *event_enabler, + const struct lttng_kernel_event_desc *event_desc) { - struct lttng_kernel_session *session = chan->parent.session; + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); + struct lttng_kernel_channel_buffer *chan = event_enabler->chan; + struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; + enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; struct lttng_kernel_event_recorder *event_recorder; struct lttng_kernel_event_recorder_private *event_recorder_priv; + struct lttng_kernel_event_common_private *event_priv; const char *event_name; struct hlist_head *head; int ret; @@ -872,26 +896,32 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l event_name = event_desc->event_name; break; - case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_UPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */ + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; case LTTNG_KERNEL_ABI_SYSCALL: event_name = event_param->name; break; - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: WARN_ON_ONCE(1); ret = -EINVAL; goto type_error; } - head = utils_borrow_hash_table_bucket(session->priv->events_ht.table, - LTTNG_EVENT_HT_SIZE, event_name); - lttng_hlist_for_each_entry(event_recorder_priv, head, hlist) { - WARN_ON_ONCE(!event_recorder_priv->parent.desc); - if (!strncmp(event_recorder_priv->parent.desc->event_name, event_name, + head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, event_name); + lttng_hlist_for_each_entry(event_priv, head, hlist_node) { + event_recorder_priv = container_of(event_priv, struct lttng_kernel_event_recorder_private, parent); + + WARN_ON_ONCE(!event_priv->desc); + if (!strncmp(event_priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) && chan == event_recorder_priv->pub->chan) { ret = -EEXIST; @@ -952,7 +982,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; @@ -1007,7 +1037,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); @@ -1085,15 +1115,17 @@ 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); WARN_ON_ONCE(!ret); break; - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: WARN_ON_ONCE(1); ret = -EINVAL; @@ -1104,7 +1136,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l if (ret) { goto statedump_error; } - hlist_add_head(&event_recorder->priv->hlist, head); + hlist_add_head(&event_recorder->priv->parent.hlist_node, head); list_add(&event_recorder->priv->node, &chan->parent.session->priv->events); return event_recorder; @@ -1121,15 +1153,17 @@ full: return ERR_PTR(ret); } -struct lttng_kernel_event_notifier *_lttng_event_notifier_create( - const struct lttng_kernel_event_desc *event_desc, - uint64_t token, uint64_t error_counter_index, - struct lttng_event_notifier_group *event_notifier_group, - struct lttng_kernel_abi_event_notifier *event_notifier_param, - enum lttng_kernel_abi_instrumentation itype) +struct lttng_kernel_event_notifier *_lttng_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler, + const struct lttng_kernel_event_desc *event_desc) { + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); + struct lttng_event_notifier_group *event_notifier_group = event_enabler->group; + struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; + uint64_t token = event_enabler->parent.user_token; + enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; struct lttng_kernel_event_notifier *event_notifier; struct lttng_kernel_event_notifier_private *event_notifier_priv; + struct lttng_kernel_event_common_private *event_priv; struct lttng_counter *error_counter; const char *event_name; struct hlist_head *head; @@ -1140,29 +1174,35 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( event_name = event_desc->event_name; break; - case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_UPROBE: /* Fall-through */ + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + lttng_fallthrough; case LTTNG_KERNEL_ABI_SYSCALL: - event_name = event_notifier_param->event.name; + event_name = event_param->name; break; - case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + 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); ret = -EINVAL; goto type_error; } - head = utils_borrow_hash_table_bucket(event_notifier_group->event_notifiers_ht.table, - LTTNG_EVENT_NOTIFIER_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, + head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, event_name); + lttng_hlist_for_each_entry(event_priv, head, hlist_node) { + event_notifier_priv = container_of(event_priv, struct lttng_kernel_event_notifier_private, parent); + + WARN_ON_ONCE(!event_priv->desc); + if (!strncmp(event_priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) && event_notifier_group == event_notifier_priv->group - && token == event_notifier_priv->parent.user_token) { + && token == event_priv->user_token) { ret = -EEXIST; goto exist; } @@ -1185,8 +1225,8 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( event_notifier->parent.type = LTTNG_KERNEL_EVENT_TYPE_NOTIFIER; event_notifier->priv->group = event_notifier_group; - event_notifier->priv->parent.user_token = token; - event_notifier->priv->error_counter_index = error_counter_index; + event_notifier->priv->parent.user_token = event_enabler->parent.user_token; + event_notifier->priv->error_counter_index = event_enabler->error_counter_index; event_notifier->priv->num_captures = 0; event_notifier->priv->parent.instrumentation = itype; event_notifier->notification_send = lttng_event_notifier_notification_send; @@ -1221,11 +1261,11 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( * registration. */ smp_wmb(); - ret = lttng_kprobes_register_event_notifier( - event_notifier_param->event.u.kprobe.symbol_name, - event_notifier_param->event.u.kprobe.offset, - event_notifier_param->event.u.kprobe.addr, - event_notifier); + ret = lttng_kprobes_register_event(event_param->u.kprobe.symbol_name, + event_param->u.kprobe.symbol_name, + event_param->u.kprobe.offset, + event_param->u.kprobe.addr, + &event_notifier->parent); if (ret) { ret = -EINVAL; goto register_error; @@ -1242,7 +1282,7 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( event_notifier->parent.enabled = 0; event_notifier->priv->parent.registered = 0; event_notifier->priv->parent.desc = event_desc; - switch (event_notifier_param->event.u.syscall.entryexit) { + switch (event_param->u.syscall.entryexit) { case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: ret = -EINVAL; goto register_error; @@ -1253,7 +1293,7 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT; break; } - switch (event_notifier_param->event.u.syscall.abi) { + switch (event_param->u.syscall.abi) { case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL: ret = -EINVAL; goto register_error; @@ -1285,19 +1325,21 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( */ smp_wmb(); - ret = lttng_uprobes_register_event_notifier( - event_notifier_param->event.name, - event_notifier_param->event.u.uprobe.fd, - event_notifier); + ret = lttng_uprobes_register_event(event_param->name, + event_param->u.uprobe.fd, + &event_notifier->parent); if (ret) goto register_error; ret = try_module_get(event_notifier->priv->parent.desc->owner); WARN_ON_ONCE(!ret); break; - case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + 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); ret = -EINVAL; @@ -1305,7 +1347,7 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create( } list_add(&event_notifier->priv->node, &event_notifier_group->event_notifiers_head); - hlist_add_head(&event_notifier->priv->hlist, head); + hlist_add_head(&event_notifier->priv->parent.hlist_node, head); /* * Clear the error counter bucket. The sessiond keeps track of which @@ -1370,79 +1412,81 @@ int lttng_kernel_counter_clear(struct lttng_counter *counter, return counter->ops->counter_clear(counter->counter, dim_indexes); } -struct lttng_kernel_event_recorder *lttng_kernel_event_recorder_create(struct lttng_kernel_channel_buffer *chan, - struct lttng_kernel_abi_event *event_param, - const struct lttng_kernel_event_desc *event_desc, - enum lttng_kernel_abi_instrumentation itype) +struct lttng_kernel_event_recorder *lttng_kernel_event_recorder_create(struct lttng_event_recorder_enabler *event_enabler, + const struct lttng_kernel_event_desc *event_desc) { struct lttng_kernel_event_recorder *event; mutex_lock(&sessions_mutex); - event = _lttng_kernel_event_recorder_create(chan, event_param, event_desc, itype); + event = _lttng_kernel_event_recorder_create(event_enabler, event_desc); mutex_unlock(&sessions_mutex); return event; } -struct lttng_kernel_event_notifier *lttng_event_notifier_create( - const struct lttng_kernel_event_desc *event_desc, - uint64_t id, uint64_t error_counter_index, - struct lttng_event_notifier_group *event_notifier_group, - struct lttng_kernel_abi_event_notifier *event_notifier_param, - enum lttng_kernel_abi_instrumentation itype) +struct lttng_kernel_event_notifier *lttng_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler, + const struct lttng_kernel_event_desc *event_desc) { struct lttng_kernel_event_notifier *event_notifier; mutex_lock(&sessions_mutex); - event_notifier = _lttng_event_notifier_create(event_desc, id, - error_counter_index, event_notifier_group, - event_notifier_param, itype); + event_notifier = _lttng_event_notifier_create(event_enabler, event_desc); mutex_unlock(&sessions_mutex); return event_notifier; } /* Only used for tracepoints for now. */ static -void register_event(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(event_recorder->chan, event_recorder); + ret = lttng_syscall_filter_enable_event(event); break; - case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_UPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_KRETPROBE: + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: ret = 0; break; - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + 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: + lttng_fallthrough; default: 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_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; @@ -1454,33 +1498,48 @@ 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); 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(event_recorder->chan, 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; - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; default: WARN_ON_ONCE(1); } @@ -1489,86 +1548,6 @@ int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder) 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: /* Fall-through */ - case LTTNG_KERNEL_ABI_UPROBE: - ret = 0; - break; - - case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */ - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ - 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: /* Fall-through */ - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ - default: - WARN_ON_ONCE(1); - } - if (!ret) - event_notifier->priv->parent.registered = 0; - return ret; -} - /* * Only used internally at session destruction. */ @@ -1597,12 +1576,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: @@ -1610,11 +1589,13 @@ 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: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: WARN_ON_ONCE(1); } @@ -1635,7 +1616,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: @@ -1643,12 +1624,15 @@ 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: /* Fall-through */ - case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */ + 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); } @@ -1938,7 +1922,7 @@ int lttng_match_enabler_name(const char *desc_name, } int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, - struct lttng_enabler *enabler) + struct lttng_event_enabler_common *enabler) { const char *desc_name, *enabler_name; bool compat = false, entry = false; @@ -2027,10 +2011,10 @@ int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, } static -int lttng_event_enabler_match_event(struct lttng_event_enabler *event_enabler, +int lttng_event_enabler_match_event(struct lttng_event_recorder_enabler *event_enabler, struct lttng_kernel_event_recorder *event_recorder) { - struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler( + struct lttng_event_enabler_common *base_enabler = lttng_event_recorder_enabler_as_enabler( event_enabler); if (base_enabler->event_param.instrumentation != event_recorder->priv->parent.instrumentation) @@ -2046,14 +2030,14 @@ static int lttng_event_notifier_enabler_match_event_notifier(struct lttng_event_notifier_enabler *event_notifier_enabler, struct lttng_kernel_event_notifier *event_notifier) { - struct lttng_enabler *base_enabler = lttng_event_notifier_enabler_as_enabler( + struct lttng_event_enabler_common *base_enabler = lttng_event_notifier_enabler_as_enabler( event_notifier_enabler); if (base_enabler->event_param.instrumentation != event_notifier->priv->parent.instrumentation) return 0; if (lttng_desc_match_enabler(event_notifier->priv->parent.desc, base_enabler) && event_notifier->priv->group == event_notifier_enabler->group - && event_notifier->priv->parent.user_token == event_notifier_enabler->base.user_token) + && event_notifier->priv->parent.user_token == event_notifier_enabler->parent.user_token) return 1; else return 0; @@ -2062,7 +2046,7 @@ int lttng_event_notifier_enabler_match_event_notifier(struct lttng_event_notifie static struct lttng_enabler_ref *lttng_enabler_ref( struct list_head *enablers_ref_list, - struct lttng_enabler *enabler) + struct lttng_event_enabler_common *enabler) { struct lttng_enabler_ref *enabler_ref; @@ -2074,9 +2058,9 @@ struct lttng_enabler_ref *lttng_enabler_ref( } static -void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_enabler) +void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) { - struct lttng_kernel_session *session = event_enabler->chan->parent.session; + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); struct lttng_kernel_probe_desc *probe_desc; const struct lttng_kernel_event_desc *desc; int i; @@ -2092,23 +2076,23 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_ for (i = 0; i < probe_desc->nr_events; i++) { int found = 0; struct hlist_head *head; - struct lttng_kernel_event_recorder_private *event_recorder_private; + struct lttng_kernel_event_recorder_private *event_recorder_priv; struct lttng_kernel_event_recorder *event_recorder; + struct lttng_kernel_event_common_private *event_priv; desc = probe_desc->event_desc[i]; if (!lttng_desc_match_enabler(desc, - lttng_event_enabler_as_enabler(event_enabler))) + lttng_event_recorder_enabler_as_enabler(event_enabler))) continue; /* * Check if already created. */ - head = utils_borrow_hash_table_bucket( - session->priv->events_ht.table, LTTNG_EVENT_HT_SIZE, - desc->event_name); - lttng_hlist_for_each_entry(event_recorder_private, head, hlist) { - if (event_recorder_private->parent.desc == desc - && event_recorder_private->pub->chan == event_enabler->chan) + head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, desc->event_name); + lttng_hlist_for_each_entry(event_priv, head, hlist_node) { + event_recorder_priv = container_of(event_priv, struct lttng_kernel_event_recorder_private, parent); + if (event_priv->desc == desc + && event_recorder_priv->pub->chan == event_enabler->chan) found = 1; } if (found) @@ -2118,8 +2102,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_ * We need to create an event for this * event probe. */ - event_recorder = _lttng_kernel_event_recorder_create(event_enabler->chan, - NULL, desc, LTTNG_KERNEL_ABI_TRACEPOINT); + event_recorder = _lttng_kernel_event_recorder_create(event_enabler, desc); if (!event_recorder) { printk(KERN_INFO "LTTng: Unable to create event %s\n", probe_desc->event_desc[i]->event_name); @@ -2131,7 +2114,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_ static void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler) { - struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group; + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_notifier_enabler->parent); struct lttng_kernel_probe_desc *probe_desc; const struct lttng_kernel_event_desc *desc; int i; @@ -2147,8 +2130,8 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi for (i = 0; i < probe_desc->nr_events; i++) { int found = 0; struct hlist_head *head; - struct lttng_kernel_event_notifier_private *event_notifier_priv; struct lttng_kernel_event_notifier *event_notifier; + struct lttng_kernel_event_common_private *event_priv; desc = probe_desc->event_desc[i]; if (!lttng_desc_match_enabler(desc, @@ -2158,12 +2141,11 @@ 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); - 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->base.user_token) + head = utils_borrow_hash_table_bucket(events_ht->table, + LTTNG_EVENT_HT_SIZE, desc->event_name); + lttng_hlist_for_each_entry(event_priv, head, hlist_node) { + if (event_priv->desc == desc + && event_priv->user_token == event_notifier_enabler->parent.user_token) found = 1; } if (found) @@ -2172,11 +2154,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi /* * We need to create a event_notifier for this event probe. */ - event_notifier = _lttng_event_notifier_create(desc, - event_notifier_enabler->base.user_token, - event_notifier_enabler->error_counter_index, - event_notifier_group, NULL, - LTTNG_KERNEL_ABI_TRACEPOINT); + event_notifier = _lttng_event_notifier_create(event_notifier_enabler, desc); if (IS_ERR(event_notifier)) { printk(KERN_INFO "Unable to create event_notifier %s\n", probe_desc->event_desc[i]->event_name); @@ -2186,7 +2164,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi } static -void lttng_create_syscall_event_if_missing(struct lttng_event_enabler *event_enabler) +void lttng_create_syscall_event_if_missing(struct lttng_event_enabler_common *event_enabler) { int ret; @@ -2194,32 +2172,21 @@ void lttng_create_syscall_event_if_missing(struct lttng_event_enabler *event_ena 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. * Should be called with sessions mutex held. */ static -void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler) +void lttng_create_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) { - switch (event_enabler->base.event_param.instrumentation) { + switch (event_enabler->parent.event_param.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: lttng_create_tracepoint_event_if_missing(event_enabler); 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: @@ -2234,11 +2201,11 @@ void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler) * Should be called with sessions mutex held. */ static -int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) +int lttng_event_enabler_ref_events(struct lttng_event_recorder_enabler *event_enabler) { struct lttng_kernel_channel_buffer *chan = event_enabler->chan; struct lttng_kernel_session *session = event_enabler->chan->parent.session; - struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler(event_enabler); + 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 && @@ -2249,10 +2216,10 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) 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(chan->priv->parent.syscall_all_entry, enabled); + WRITE_ONCE(chan->priv->parent.syscall_table.syscall_all_entry, enabled); if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - WRITE_ONCE(chan->priv->parent.syscall_all_exit, enabled); + WRITE_ONCE(chan->priv->parent.syscall_table.syscall_all_exit, enabled); } /* First ensure that probe events are created for this enabler. */ @@ -2266,7 +2233,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) if (!lttng_event_enabler_match_event(event_enabler, event_recorder)) continue; enabler_ref = lttng_enabler_ref(&event_recorder_priv->parent.enablers_ref_head, - lttng_event_enabler_as_enabler(event_enabler)); + lttng_event_recorder_enabler_as_enabler(event_enabler)); if (!enabler_ref) { /* * If no backward ref, create it. @@ -2275,7 +2242,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL); if (!enabler_ref) return -ENOMEM; - enabler_ref->ref = lttng_event_enabler_as_enabler(event_enabler); + enabler_ref->ref = lttng_event_recorder_enabler_as_enabler(event_enabler); list_add(&enabler_ref->node, &event_recorder_priv->parent.enablers_ref_head); } @@ -2286,7 +2253,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) lttng_enabler_link_bytecode(event_recorder_priv->parent.desc, lttng_static_ctx, &event_recorder_priv->parent.filter_bytecode_runtime_head, - <tng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head); + <tng_event_recorder_enabler_as_enabler(event_enabler)->filter_bytecode_head); } return 0; } @@ -2299,13 +2266,13 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) static void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler) { - switch (event_notifier_enabler->base.event_param.instrumentation) { + switch (event_notifier_enabler->parent.event_param.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: lttng_create_tracepoint_event_notifier_if_missing(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: @@ -2322,7 +2289,7 @@ int lttng_event_notifier_enabler_ref_event_notifiers( struct lttng_event_notifier_enabler *event_notifier_enabler) { struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group; - struct lttng_enabler *base_enabler = lttng_event_notifier_enabler_as_enabler(event_notifier_enabler); + 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 && @@ -2334,10 +2301,10 @@ int lttng_event_notifier_enabler_ref_event_notifiers( 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_all_entry, enabled); + 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_all_exit, enabled); + WRITE_ONCE(event_notifier_group->syscall_table.syscall_all_exit, enabled); } @@ -2407,7 +2374,7 @@ static bool lttng_event_notifier_group_has_active_event_notifiers( list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, node) { - if (event_notifier_enabler->base.enabled) + if (event_notifier_enabler->parent.enabled) return true; } return false; @@ -2433,50 +2400,57 @@ int lttng_fix_pending_event_notifiers(void) return 0; } -struct lttng_event_enabler *lttng_event_enabler_create( +struct lttng_event_recorder_enabler *lttng_event_recorder_enabler_create( enum lttng_enabler_format_type format_type, struct lttng_kernel_abi_event *event_param, struct lttng_kernel_channel_buffer *chan) { - struct lttng_event_enabler *event_enabler; + struct lttng_event_recorder_enabler *event_enabler; event_enabler = kzalloc(sizeof(*event_enabler), GFP_KERNEL); if (!event_enabler) return NULL; - event_enabler->base.format_type = format_type; - INIT_LIST_HEAD(&event_enabler->base.filter_bytecode_head); - memcpy(&event_enabler->base.event_param, event_param, - sizeof(event_enabler->base.event_param)); + event_enabler->parent.enabler_type = LTTNG_EVENT_ENABLER_TYPE_RECORDER; + event_enabler->parent.format_type = format_type; + INIT_LIST_HEAD(&event_enabler->parent.filter_bytecode_head); + memcpy(&event_enabler->parent.event_param, event_param, + sizeof(event_enabler->parent.event_param)); event_enabler->chan = chan; /* ctx left NULL */ - event_enabler->base.enabled = 0; + event_enabler->parent.enabled = 0; + return event_enabler; +} + +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, &event_enabler->chan->parent.session->priv->enablers_head); - lttng_session_lazy_sync_event_enablers(event_enabler->chan->parent.session); + list_add(&event_enabler->node, &session->priv->enablers_head); + event_enabler->published = true; + lttng_session_lazy_sync_event_enablers(session); mutex_unlock(&sessions_mutex); - return event_enabler; } -int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler) +int lttng_event_enabler_enable(struct lttng_event_enabler_common *event_enabler) { mutex_lock(&sessions_mutex); - lttng_event_enabler_as_enabler(event_enabler)->enabled = 1; - lttng_session_lazy_sync_event_enablers(event_enabler->chan->parent.session); + event_enabler->enabled = 1; + lttng_event_enabler_sync(event_enabler); mutex_unlock(&sessions_mutex); return 0; } -int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler) +int lttng_event_enabler_disable(struct lttng_event_enabler_common *event_enabler) { mutex_lock(&sessions_mutex); - lttng_event_enabler_as_enabler(event_enabler)->enabled = 0; - lttng_session_lazy_sync_event_enablers(event_enabler->chan->parent.session); + event_enabler->enabled = 0; + lttng_event_enabler_sync(event_enabler); mutex_unlock(&sessions_mutex); return 0; } static -int lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler, +int lttng_enabler_attach_filter_bytecode(struct lttng_event_enabler_common *enabler, struct lttng_kernel_abi_filter_bytecode __user *bytecode) { struct lttng_kernel_bytecode_node *bytecode_node; @@ -2508,16 +2482,14 @@ error_free: return ret; } -int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler, +int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler_common *event_enabler, struct lttng_kernel_abi_filter_bytecode __user *bytecode) { int ret; - ret = lttng_enabler_attach_filter_bytecode( - lttng_event_enabler_as_enabler(event_enabler), bytecode); + ret = lttng_enabler_attach_filter_bytecode(event_enabler, bytecode); if (ret) goto error; - - lttng_session_lazy_sync_event_enablers(event_enabler->chan->parent.session); + lttng_event_enabler_sync(event_enabler); return 0; error: @@ -2537,7 +2509,7 @@ int lttng_event_add_callsite(struct lttng_kernel_event_common *event, } static -void lttng_enabler_destroy(struct lttng_enabler *enabler) +void lttng_enabler_destroy(struct lttng_event_enabler_common *enabler) { struct lttng_kernel_bytecode_node *filter_node, *tmp_filter_node; @@ -2548,19 +2520,40 @@ void lttng_enabler_destroy(struct lttng_enabler *enabler) } } -static -void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler) +void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enabler) { - lttng_enabler_destroy(lttng_event_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); + + 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_enabler->node); - kfree(event_enabler); + lttng_enabler_destroy(event_enabler); + if (event_notifier_enabler->published) + list_del(&event_notifier_enabler->node); + kfree(event_notifier_enabler); + break; + } + default: + WARN_ON_ONCE(1); + } } struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create( - struct lttng_event_notifier_group *event_notifier_group, enum lttng_enabler_format_type format_type, - struct lttng_kernel_abi_event_notifier *event_notifier_param) + struct lttng_kernel_abi_event_notifier *event_notifier_param, + struct lttng_event_notifier_group *event_notifier_group) { struct lttng_event_notifier_enabler *event_notifier_enabler; @@ -2568,27 +2561,31 @@ struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create( if (!event_notifier_enabler) return NULL; - event_notifier_enabler->base.format_type = format_type; - INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head); + event_notifier_enabler->parent.enabler_type = LTTNG_EVENT_ENABLER_TYPE_NOTIFIER; + event_notifier_enabler->parent.format_type = format_type; + INIT_LIST_HEAD(&event_notifier_enabler->parent.filter_bytecode_head); INIT_LIST_HEAD(&event_notifier_enabler->capture_bytecode_head); 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, &event_notifier_param->event, - sizeof(event_notifier_enabler->base.event_param)); + memcpy(&event_notifier_enabler->parent.event_param, &event_notifier_param->event, + sizeof(event_notifier_enabler->parent.event_param)); - event_notifier_enabler->base.enabled = 0; - event_notifier_enabler->base.user_token = event_notifier_param->event.token; + event_notifier_enabler->parent.enabled = 0; + event_notifier_enabler->parent.user_token = event_notifier_param->event.token; event_notifier_enabler->group = event_notifier_group; + return event_notifier_enabler; +} +void lttng_event_notifier_enabler_group_add(struct lttng_event_notifier_group *event_notifier_group, + 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; lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); - mutex_unlock(&sessions_mutex); - - return event_notifier_enabler; } int lttng_event_notifier_enabler_enable( @@ -2611,31 +2608,12 @@ int lttng_event_notifier_enabler_disable( return 0; } -int lttng_event_notifier_enabler_attach_filter_bytecode( - struct lttng_event_notifier_enabler *event_notifier_enabler, - struct lttng_kernel_abi_filter_bytecode __user *bytecode) -{ - int ret; - - ret = lttng_enabler_attach_filter_bytecode( - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler), - bytecode); - if (ret) - goto error; - - lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); - return 0; - -error: - return ret; -} - int lttng_event_notifier_enabler_attach_capture_bytecode( struct lttng_event_notifier_enabler *event_notifier_enabler, struct lttng_kernel_abi_capture_bytecode __user *bytecode) { struct lttng_kernel_bytecode_node *bytecode_node; - struct lttng_enabler *enabler = + struct lttng_event_enabler_common *enabler = lttng_event_notifier_enabler_as_enabler(event_notifier_enabler); uint32_t bytecode_len; int ret; @@ -2672,20 +2650,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. @@ -2694,7 +2658,7 @@ void lttng_event_notifier_enabler_destroy( static void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) { - struct lttng_event_enabler *event_enabler; + struct lttng_event_recorder_enabler *event_enabler; struct lttng_kernel_event_recorder_private *event_recorder_priv; list_for_each_entry(event_enabler, &session->priv->enablers_head, node) @@ -2712,7 +2676,8 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) int nr_filters = 0; switch (event_recorder_priv->parent.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: /* Fall-through */ + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; case LTTNG_KERNEL_ABI_SYSCALL: /* Enable events */ list_for_each_entry(enabler_ref, @@ -2741,9 +2706,9 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) * state. */ if (enabled) { - register_event(event_recorder); + register_event(&event_recorder->parent); } else { - _lttng_event_unregister(event_recorder); + _lttng_event_unregister(&event_recorder->parent); } /* Check if has enablers without bytecode enabled */ @@ -2806,7 +2771,8 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group int nr_filters = 0, nr_captures = 0; switch (event_notifier_priv->parent.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: /* Fall-through */ + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; case LTTNG_KERNEL_ABI_SYSCALL: /* Enable event_notifiers */ list_for_each_entry(enabler_ref, @@ -2830,10 +2796,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 */ @@ -2867,6 +2833,29 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group } } +static +void lttng_event_enabler_sync(struct lttng_event_enabler_common *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); + lttng_session_lazy_sync_event_enablers(event_recorder_enabler->chan->parent.session); + 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); + lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); + break; + } + default: + WARN_ON_ONCE(1); + } +} + /* * Serialize at most one packet worth of metadata into a metadata * channel. @@ -3876,7 +3865,7 @@ int print_escaped_ctf_string(struct lttng_kernel_session *session, const char *s if (ret) goto error; /* We still print the current char */ - /* Fallthrough */ + lttng_fallthrough; default: ret = lttng_metadata_printf(session, "%c", cur); break;