X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=src%2Flttng-events.c;h=5023d450b1bd77f50969776c32b8e2735a192317;hp=f5c0fa95a5233e604e4312c2b6c773dc6a87960f;hb=HEAD;hpb=44b1abdc77d0587d2b800584b7b6612a4fbcb96b diff --git a/src/lttng-events.c b/src/lttng-events.c index f5c0fa95..73f591fd 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -23,7 +23,6 @@ #include #include #include -#include #include #include #include @@ -47,7 +46,13 @@ #include #include #include -#include + +#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,16,0) \ + || LTTNG_RHEL_KERNEL_RANGE(5,14,0,162,0,0, 5,15,0,0,0,0)) +#include +#else +#include +#endif #define METADATA_CACHE_DEFAULT_SIZE 4096 @@ -71,12 +76,9 @@ 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_unregister(struct lttng_kernel_event_recorder *event); -static int _lttng_event_notifier_unregister(struct lttng_kernel_event_notifier *event_notifier); +static void _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, - struct lttng_kernel_event_recorder *event); +int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event); static int _lttng_session_metadata_statedump(struct lttng_kernel_session *session); static @@ -100,15 +102,9 @@ void synchronize_trace(void) synchronize_sched(); #endif -#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) #ifdef CONFIG_PREEMPT_RT_FULL synchronize_rcu(); #endif -#else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */ -#ifdef CONFIG_PREEMPT_RT - synchronize_rcu(); -#endif -#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */ } void lttng_lock_sessions(void) @@ -322,8 +318,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); @@ -354,28 +350,25 @@ void lttng_session_destroy(struct lttng_kernel_session *session) struct lttng_kernel_channel_buffer_private *chan_priv, *tmpchan_priv; struct lttng_kernel_event_recorder_private *event_recorder_priv, *tmpevent_recorder_priv; struct lttng_metadata_stream *metadata_stream; - struct lttng_event_recorder_enabler *event_recorder_enabler, *tmp_event_recorder_enabler; + struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler; int ret; mutex_lock(&sessions_mutex); WRITE_ONCE(session->active, 0); list_for_each_entry(chan_priv, &session->priv->chan, node) { - ret = lttng_syscalls_unregister_channel(chan_priv->pub); - WARN_ON(ret); - } - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { - ret = _lttng_event_unregister(event_recorder_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, parent.node) + _lttng_event_unregister(&event_recorder_priv->pub->parent); 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_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); @@ -401,7 +394,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session) void lttng_event_notifier_group_destroy( struct lttng_event_notifier_group *event_notifier_group) { - struct lttng_event_notifier_enabler *event_notifier_enabler, *tmp_event_notifier_enabler; + struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler; struct lttng_kernel_event_notifier_private *event_notifier_priv, *tmpevent_notifier_priv; int ret; @@ -410,28 +403,27 @@ 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); - WARN_ON(ret); - } + &event_notifier_group->event_notifiers_head, parent.node) + _lttng_event_unregister(&event_notifier_priv->pub->parent); /* Wait for in-flight event notifier to complete */ synchronize_trace(); 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, + list_for_each_entry_safe(event_enabler, tmp_event_enabler, &event_notifier_group->enablers_head, node) - lttng_event_enabler_destroy(&event_notifier_enabler->parent); + lttng_event_enabler_destroy(event_enabler); list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv, - &event_notifier_group->event_notifiers_head, node) + &event_notifier_group->event_notifiers_head, parent.node) _lttng_event_destroy(&event_notifier_priv->pub->parent); if (event_notifier_group->error_counter) { @@ -567,7 +559,7 @@ int lttng_session_metadata_regenerate(struct lttng_kernel_session *session) chan_priv->metadata_dumped = 0; } - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { event_recorder_priv->metadata_dumped = 0; } @@ -578,47 +570,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 +757,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, @@ -854,25 +859,217 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream) wake_up_interruptible(&stream->read_wait); } +static +bool lttng_kernel_event_id_available(struct lttng_event_enabler_common *event_enabler) +{ + struct lttng_kernel_abi_event *event_param = &event_enabler->event_param; + enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; + + 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); + struct lttng_kernel_channel_buffer *chan = event_recorder_enabler->chan; + + switch (itype) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + if (chan->priv->free_event_id == -1U) + return false; + return true; + case LTTNG_KERNEL_ABI_KRETPROBE: + /* kretprobes require 2 event IDs. */ + if (chan->priv->free_event_id >= -2U) + return false; + return true; + default: + WARN_ON_ONCE(1); + return false; + } + } + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + return true; + default: + WARN_ON_ONCE(1); + return false; + } +} + +static +struct lttng_kernel_event_common *lttng_kernel_event_alloc(struct lttng_event_enabler_common *event_enabler) +{ + struct lttng_kernel_abi_event *event_param = &event_enabler->event_param; + enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; + + 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); + struct lttng_kernel_event_recorder *event_recorder; + struct lttng_kernel_event_recorder_private *event_recorder_priv; + struct lttng_kernel_channel_buffer *chan = event_recorder_enabler->chan; + + event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL); + if (!event_recorder) + return NULL; + event_recorder_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL); + if (!event_recorder_priv) { + kmem_cache_free(event_recorder_private_cache, event_recorder); + return NULL; + } + event_recorder_priv->pub = event_recorder; + event_recorder_priv->parent.pub = &event_recorder->parent; + event_recorder->priv = event_recorder_priv; + event_recorder->parent.priv = &event_recorder_priv->parent; + + event_recorder->parent.type = LTTNG_KERNEL_EVENT_TYPE_RECORDER; + event_recorder->parent.run_filter = lttng_kernel_interpret_event_filter; + event_recorder->priv->parent.instrumentation = itype; + INIT_LIST_HEAD(&event_recorder->priv->parent.filter_bytecode_runtime_head); + INIT_LIST_HEAD(&event_recorder->priv->parent.enablers_ref_head); + + event_recorder->chan = chan; + event_recorder->priv->id = chan->priv->free_event_id++; + return &event_recorder->parent; + } + 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; + struct lttng_kernel_event_notifier_private *event_notifier_priv; + + event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL); + if (!event_notifier) + return NULL; + event_notifier_priv = kmem_cache_zalloc(event_notifier_private_cache, GFP_KERNEL); + if (!event_notifier_priv) { + kmem_cache_free(event_notifier_private_cache, event_notifier); + return NULL; + } + event_notifier_priv->pub = event_notifier; + event_notifier_priv->parent.pub = &event_notifier->parent; + event_notifier->priv = event_notifier_priv; + event_notifier->parent.priv = &event_notifier_priv->parent; + + event_notifier->parent.type = LTTNG_KERNEL_EVENT_TYPE_NOTIFIER; + event_notifier->parent.run_filter = lttng_kernel_interpret_event_filter; + event_notifier->priv->parent.instrumentation = itype; + event_notifier->priv->parent.user_token = event_enabler->user_token; + INIT_LIST_HEAD(&event_notifier->priv->parent.filter_bytecode_runtime_head); + INIT_LIST_HEAD(&event_notifier->priv->parent.enablers_ref_head); + + event_notifier->priv->group = event_notifier_enabler->group; + event_notifier->priv->error_counter_index = event_notifier_enabler->error_counter_index; + event_notifier->priv->num_captures = 0; + event_notifier->notification_send = lttng_event_notifier_notification_send; + INIT_LIST_HEAD(&event_notifier->priv->capture_bytecode_runtime_head); + return &event_notifier->parent; + } + default: + return NULL; + } +} + +static +void lttng_kernel_event_free(struct lttng_kernel_event_common *event) +{ + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + { + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + kmem_cache_free(event_recorder_private_cache, event_recorder->priv); + kmem_cache_free(event_recorder_cache, event_recorder); + break; + } + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + { + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + + kmem_cache_free(event_notifier_private_cache, event_notifier->priv); + kmem_cache_free(event_notifier_cache, event_notifier); + break; + } + default: + WARN_ON_ONCE(1); + } +} + +static +int lttng_kernel_event_notifier_clear_error_counter(struct lttng_kernel_event_common *event) +{ + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + return 0; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + { + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + struct lttng_counter *error_counter; + struct lttng_event_notifier_group *event_notifier_group = event_notifier->priv->group; + size_t dimension_index[1]; + int ret; + + /* + * Clear the error counter bucket. The sessiond keeps track of which + * bucket is currently in use. We trust it. The session lock + * synchronizes against concurrent creation of the error + * counter. + */ + error_counter = event_notifier_group->error_counter; + if (!error_counter) + return 0; + /* + * Check that the index is within the boundary of the counter. + */ + if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) { + printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n", + event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index); + return -EINVAL; + } + + dimension_index[0] = event_notifier->priv->error_counter_index; + ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index); + if (ret) { + printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n", + event_notifier->priv->error_counter_index); + return -EINVAL; + } + return 0; + } + default: + return -EINVAL; + } +} /* * 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_event_recorder_enabler *event_enabler, +struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, const struct lttng_kernel_event_desc *event_desc) { - struct lttng_kernel_channel_buffer *chan = event_enabler->chan; - struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler); + struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler); + struct lttng_kernel_abi_event *event_param = &event_enabler->event_param; enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; - struct lttng_kernel_session *session = chan->parent.session; - struct lttng_kernel_event_recorder *event_recorder; - struct lttng_kernel_event_recorder_private *event_recorder_priv; + struct lttng_kernel_event_common_private *event_priv; + struct lttng_kernel_event_common *event; const char *event_name; struct hlist_head *head; int ret; - if (chan->priv->free_event_id == -1U) { + if (!lttng_kernel_event_id_available(event_enabler)) { ret = -EMFILE; goto full; } @@ -902,48 +1099,27 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l 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, - LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) - && chan == event_recorder_priv->pub->chan) { + 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) { + if (lttng_event_enabler_event_name_match_event(event_enabler, event_name, event_priv->pub)) { ret = -EEXIST; goto exist; } } - event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL); - if (!event_recorder) { - ret = -ENOMEM; - goto cache_error; - } - event_recorder_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL); - if (!event_recorder_priv) { + event = lttng_kernel_event_alloc(event_enabler); + if (!event) { ret = -ENOMEM; - goto cache_private_error; + goto alloc_error; } - event_recorder_priv->pub = event_recorder; - event_recorder_priv->parent.pub = &event_recorder->parent; - event_recorder->priv = event_recorder_priv; - event_recorder->parent.priv = &event_recorder_priv->parent; - event_recorder->parent.type = LTTNG_KERNEL_EVENT_TYPE_RECORDER; - - event_recorder->parent.run_filter = lttng_kernel_interpret_event_filter; - event_recorder->chan = chan; - event_recorder->priv->id = chan->priv->free_event_id++; - event_recorder->priv->parent.instrumentation = itype; - INIT_LIST_HEAD(&event_recorder->priv->parent.filter_bytecode_runtime_head); - INIT_LIST_HEAD(&event_recorder->priv->parent.enablers_ref_head); switch (itype) { case LTTNG_KERNEL_ABI_TRACEPOINT: /* Event will be enabled by enabler sync. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 0; - event_recorder->priv->parent.desc = lttng_event_desc_get(event_name); - if (!event_recorder->priv->parent.desc) { + event->enabled = 0; + event->priv->registered = 0; + event->priv->desc = lttng_event_desc_get(event_name); + if (!event->priv->desc) { ret = -ENOENT; goto register_error; } @@ -956,8 +1132,8 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 1; + event->enabled = 0; + event->priv->registered = 1; /* * Populate lttng_event structure before event * registration. @@ -967,53 +1143,36 @@ 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); if (ret) { ret = -EINVAL; goto register_error; } - ret = try_module_get(event_recorder->priv->parent.desc->owner); + ret = try_module_get(event->priv->desc->owner); WARN_ON_ONCE(!ret); break; case LTTNG_KERNEL_ABI_KRETPROBE: { - struct lttng_kernel_event_recorder *event_recorder_return; - struct lttng_kernel_event_recorder_private *event_recorder_return_priv; + struct lttng_kernel_event_common *event_return; /* kretprobe defines 2 events */ /* * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 1; + event->enabled = 0; + event->priv->registered = 1; - event_recorder_return = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL); - if (!event_recorder_return) { - ret = -ENOMEM; - goto register_error; - } - event_recorder_return_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL); - if (!event_recorder_return_priv) { - kmem_cache_free(event_recorder_cache, event_recorder_return); + event_return = lttng_kernel_event_alloc(event_enabler); + if (!event) { ret = -ENOMEM; - goto register_error; + goto alloc_error; } - event_recorder_return_priv->pub = event_recorder_return; - event_recorder_return_priv->parent.pub = &event_recorder_return->parent; - event_recorder_return->priv = event_recorder_return_priv; - event_recorder_return->parent.priv = &event_recorder_return_priv->parent; - event_recorder_return->parent.type = LTTNG_KERNEL_EVENT_TYPE_RECORDER; - - event_recorder_return->parent.run_filter = lttng_kernel_interpret_event_filter; - event_recorder_return->chan = chan; - event_recorder_return->priv->id = chan->priv->free_event_id++; - event_recorder_return->priv->parent.instrumentation = itype; - event_recorder_return->parent.enabled = 0; - event_recorder_return->priv->parent.registered = 1; - INIT_LIST_HEAD(&event_recorder_return->priv->parent.filter_bytecode_runtime_head); - INIT_LIST_HEAD(&event_recorder_return->priv->parent.enablers_ref_head); + + event_return->enabled = 0; + event_return->priv->registered = 1; + /* * Populate lttng_event structure before kretprobe registration. */ @@ -1022,29 +1181,26 @@ 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, event_return); if (ret) { - kmem_cache_free(event_recorder_private_cache, event_recorder_return_priv); - kmem_cache_free(event_recorder_cache, event_recorder_return); + lttng_kernel_event_free(event_return); ret = -EINVAL; goto register_error; } /* Take 2 refs on the module: one per event. */ - ret = try_module_get(event_recorder->priv->parent.desc->owner); + ret = try_module_get(event->priv->desc->owner); WARN_ON_ONCE(!ret); - ret = try_module_get(event_recorder_return->priv->parent.desc->owner); + ret = try_module_get(event_return->priv->desc->owner); WARN_ON_ONCE(!ret); - ret = _lttng_event_metadata_statedump(chan->parent.session, chan, - event_recorder_return); + ret = _lttng_event_recorder_metadata_statedump(event_return); WARN_ON_ONCE(ret > 0); if (ret) { - kmem_cache_free(event_recorder_private_cache, event_recorder_return_priv); - kmem_cache_free(event_recorder_cache, event_recorder_return); - module_put(event_recorder_return->priv->parent.desc->owner); - module_put(event_recorder->priv->parent.desc->owner); + lttng_kernel_event_free(event_return); + module_put(event_return->priv->desc->owner); + module_put(event->priv->desc->owner); goto statedump_error; } - list_add(&event_recorder_return->priv->node, &chan->parent.session->priv->events); + list_add(&event_return->priv->node, event_list_head); break; } @@ -1053,18 +1209,18 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 0; - event_recorder->priv->parent.desc = event_desc; + event->enabled = 0; + event->priv->registered = 0; + event->priv->desc = event_desc; switch (event_param->u.syscall.entryexit) { case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: ret = -EINVAL; goto register_error; case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: - event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; + event->priv->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; break; case LTTNG_KERNEL_ABI_SYSCALL_EXIT: - event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT; + event->priv->u.syscall.entryexit = LTTNG_SYSCALL_EXIT; break; } switch (event_param->u.syscall.abi) { @@ -1072,13 +1228,13 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l ret = -EINVAL; goto register_error; case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE: - event_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; + event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; break; case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT: - event_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; + event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; break; } - if (!event_recorder->priv->parent.desc) { + if (!event->priv->desc) { ret = -EINVAL; goto register_error; } @@ -1089,8 +1245,8 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 1; + event->enabled = 0; + event->priv->registered = 1; /* * Populate lttng_event structure before event @@ -1100,410 +1256,179 @@ 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); if (ret) goto register_error; - ret = try_module_get(event_recorder->priv->parent.desc->owner); + ret = try_module_get(event->priv->desc->owner); WARN_ON_ONCE(!ret); break; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; default: WARN_ON_ONCE(1); ret = -EINVAL; goto register_error; } - ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder); + + ret = _lttng_event_recorder_metadata_statedump(event); WARN_ON_ONCE(ret > 0); if (ret) { goto statedump_error; } - hlist_add_head(&event_recorder->priv->hlist, head); - list_add(&event_recorder->priv->node, &chan->parent.session->priv->events); - return event_recorder; + + ret = lttng_kernel_event_notifier_clear_error_counter(event); + if (ret) + goto register_error; + + hlist_add_head(&event->priv->hlist_node, head); + list_add(&event->priv->node, event_list_head); + + return event; statedump_error: /* If a statedump error occurs, events will not be readable. */ register_error: - kmem_cache_free(event_recorder_private_cache, event_recorder_priv); -cache_private_error: - kmem_cache_free(event_recorder_cache, event_recorder); -cache_error: + lttng_kernel_event_free(event); +alloc_error: exist: type_error: 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_common *lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, + const struct lttng_kernel_event_desc *event_desc) { - struct lttng_kernel_event_notifier *event_notifier; - struct lttng_kernel_event_notifier_private *event_notifier_priv; - struct lttng_counter *error_counter; - const char *event_name; - struct hlist_head *head; - int ret; + struct lttng_kernel_event_common *event; - switch (itype) { + mutex_lock(&sessions_mutex); + event = _lttng_kernel_event_create(event_enabler, event_desc); + mutex_unlock(&sessions_mutex); + return event; +} + +int lttng_kernel_counter_read(struct lttng_counter *counter, + const size_t *dim_indexes, int32_t cpu, + int64_t *val, bool *overflow, bool *underflow) +{ + return counter->ops->counter_read(counter->counter, dim_indexes, + cpu, val, overflow, underflow); +} + +int lttng_kernel_counter_aggregate(struct lttng_counter *counter, + const size_t *dim_indexes, int64_t *val, + bool *overflow, bool *underflow) +{ + return counter->ops->counter_aggregate(counter->counter, dim_indexes, + val, overflow, underflow); +} + +int lttng_kernel_counter_clear(struct lttng_counter *counter, + const size_t *dim_indexes) +{ + return counter->ops->counter_clear(counter->counter, dim_indexes); +} + +/* Only used for tracepoints and system calls for now. */ +static +void register_event(struct lttng_kernel_event_common *event) +{ + const struct lttng_kernel_event_desc *desc; + int ret = -EINVAL; + + WARN_ON_ONCE(event->priv->registered); + + desc = event->priv->desc; + switch (event->priv->instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - event_name = event_desc->event_name; + ret = lttng_tracepoint_probe_register(desc->event_kname, + desc->tp_class->probe_callback, + event); + break; + + case LTTNG_KERNEL_ABI_SYSCALL: + 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_SYSCALL: - event_name = event_notifier_param->event.name; + ret = 0; break; case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_fallthrough; + 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); - ret = -EINVAL; - goto type_error; } + WARN_ON_ONCE(ret); + if (!ret) + event->priv->registered = 1; +} - 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, - LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) - && event_notifier_group == event_notifier_priv->group - && token == event_notifier_priv->parent.user_token) { - ret = -EEXIST; - goto exist; - } - } +static +void unregister_event(struct lttng_kernel_event_common *event) +{ + struct lttng_kernel_event_common_private *event_priv = event->priv; + const struct lttng_kernel_event_desc *desc; + int ret = -EINVAL; - event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL); - if (!event_notifier) { - ret = -ENOMEM; - goto cache_error; - } - event_notifier_priv = kmem_cache_zalloc(event_notifier_private_cache, GFP_KERNEL); - if (!event_notifier_priv) { - ret = -ENOMEM; - goto cache_private_error; - } - event_notifier_priv->pub = event_notifier; - event_notifier_priv->parent.pub = &event_notifier->parent; - event_notifier->priv = event_notifier_priv; - event_notifier->parent.priv = &event_notifier_priv->parent; - 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->num_captures = 0; - event_notifier->priv->parent.instrumentation = itype; - event_notifier->notification_send = lttng_event_notifier_notification_send; - INIT_LIST_HEAD(&event_notifier->priv->parent.filter_bytecode_runtime_head); - INIT_LIST_HEAD(&event_notifier->priv->parent.enablers_ref_head); - INIT_LIST_HEAD(&event_notifier->priv->capture_bytecode_runtime_head); - event_notifier->parent.run_filter = lttng_kernel_interpret_event_filter; + WARN_ON_ONCE(!event->priv->registered); - switch (itype) { + desc = event_priv->desc; + switch (event_priv->instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - /* Event will be enabled by enabler sync. */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 0; - event_notifier->priv->parent.desc = lttng_event_desc_get(event_name); - if (!event_notifier->priv->parent.desc) { - ret = -ENOENT; - goto register_error; - } - /* Populate lttng_event_notifier structure before event registration. */ - smp_wmb(); + ret = lttng_tracepoint_probe_unregister(event_priv->desc->event_kname, + event_priv->desc->tp_class->probe_callback, + event); break; case LTTNG_KERNEL_ABI_KPROBE: - /* - * Needs to be explicitly enabled after creation, since - * we may want to apply filters. - */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 1; - /* - * Populate lttng_event_notifier structure before event - * 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); - if (ret) { - ret = -EINVAL; - goto register_error; + lttng_kprobes_unregister_event(event); + ret = 0; + break; + + case LTTNG_KERNEL_ABI_KRETPROBE: + 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; } - ret = try_module_get(event_notifier->priv->parent.desc->owner); - WARN_ON_ONCE(!ret); break; case LTTNG_KERNEL_ABI_SYSCALL: - /* - * Needs to be explicitly enabled after creation, since - * we may want to apply filters. - */ - 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) { - case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: - ret = -EINVAL; - goto register_error; - case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: - event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; - break; - case LTTNG_KERNEL_ABI_SYSCALL_EXIT: - event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT; - break; - } - switch (event_notifier_param->event.u.syscall.abi) { - case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL: - ret = -EINVAL; - goto register_error; - case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE: - event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; - break; - case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT: - event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; - break; - } - - if (!event_notifier->priv->parent.desc) { - ret = -EINVAL; - goto register_error; - } + ret = lttng_syscall_filter_disable_event(event); break; - case LTTNG_KERNEL_ABI_UPROBE: - /* - * Needs to be explicitly enabled after creation, since - * we may want to apply filters. - */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 1; - - /* - * Populate lttng_event_notifier structure before - * event_notifier registration. - */ - smp_wmb(); - - ret = lttng_uprobes_register_event_notifier( - event_notifier_param->event.name, - event_notifier_param->event.u.uprobe.fd, - event_notifier); - 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: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; - default: - WARN_ON_ONCE(1); - ret = -EINVAL; - goto register_error; - } - - list_add(&event_notifier->priv->node, &event_notifier_group->event_notifiers_head); - hlist_add_head(&event_notifier->priv->hlist, head); - - /* - * Clear the error counter bucket. The sessiond keeps track of which - * bucket is currently in use. We trust it. The session lock - * synchronizes against concurrent creation of the error - * counter. - */ - error_counter = event_notifier_group->error_counter; - if (error_counter) { - size_t dimension_index[1]; - - /* - * Check that the index is within the boundary of the counter. - */ - if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) { - printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n", - event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index); - ret = -EINVAL; - goto register_error; - } - - dimension_index[0] = event_notifier->priv->error_counter_index; - ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index); - if (ret) { - printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n", - event_notifier->priv->error_counter_index); - goto register_error; + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + ret = 0; + break; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + WARN_ON_ONCE(1); + break; } - } - - return event_notifier; - -register_error: - kmem_cache_free(event_notifier_private_cache, event_notifier_priv); -cache_private_error: - kmem_cache_free(event_notifier_cache, event_notifier); -cache_error: -exist: -type_error: - return ERR_PTR(ret); -} - -int lttng_kernel_counter_read(struct lttng_counter *counter, - const size_t *dim_indexes, int32_t cpu, - int64_t *val, bool *overflow, bool *underflow) -{ - return counter->ops->counter_read(counter->counter, dim_indexes, - cpu, val, overflow, underflow); -} - -int lttng_kernel_counter_aggregate(struct lttng_counter *counter, - const size_t *dim_indexes, int64_t *val, - bool *overflow, bool *underflow) -{ - return counter->ops->counter_aggregate(counter->counter, dim_indexes, - val, overflow, underflow); -} - -int lttng_kernel_counter_clear(struct lttng_counter *counter, - const size_t *dim_indexes) -{ - return counter->ops->counter_clear(counter->counter, dim_indexes); -} - -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(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 *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); - mutex_unlock(&sessions_mutex); - return event_notifier; -} - -/* Only used for tracepoints for now. */ -static -void register_event(struct lttng_kernel_event_recorder *event_recorder) -{ - const struct lttng_kernel_event_desc *desc; - int ret = -EINVAL; - - if (event_recorder->priv->parent.registered) - return; - - desc = event_recorder->priv->parent.desc; - switch (event_recorder->priv->parent.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname, - desc->tp_class->probe_callback, - event_recorder); - break; - - case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_enable_event(event_recorder->chan, event_recorder); - 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_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; - default: - WARN_ON_ONCE(1); - } - if (!ret) - event_recorder->priv->parent.registered = 1; -} - -/* - * Only used internally at session destruction. - */ -int _lttng_event_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; - int ret = -EINVAL; - - if (!event_priv->registered) - return 0; - - desc = event_priv->desc; - switch (event_priv->instrumentation) { - 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); - break; - - case LTTNG_KERNEL_ABI_KPROBE: - lttng_kprobes_unregister_event(event_recorder); - ret = 0; - break; - - case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_kretprobes_unregister(event_recorder); - ret = 0; - break; - - case LTTNG_KERNEL_ABI_SYSCALL: - ret = lttng_syscall_filter_disable_event(event_recorder->chan, event_recorder); - break; - - case LTTNG_KERNEL_ABI_NOOP: - ret = 0; break; case LTTNG_KERNEL_ABI_UPROBE: - lttng_uprobes_unregister_event(event_recorder); + lttng_uprobes_unregister_event(event); ret = 0; break; @@ -1512,96 +1437,16 @@ int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder) default: WARN_ON_ONCE(1); } + WARN_ON_ONCE(ret); if (!ret) event_priv->registered = 0; - 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) +void _lttng_event_unregister(struct lttng_kernel_event_common *event) { - 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; + if (event->priv->registered) + unregister_event(event); } /* @@ -1632,12 +1477,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 +1490,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: @@ -1655,7 +1500,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) default: WARN_ON_ONCE(1); } - list_del(&event_recorder->priv->node); + list_del(&event_recorder->priv->parent.node); kmem_cache_free(event_recorder_private_cache, event_recorder->priv); kmem_cache_free(event_recorder_cache, event_recorder); break; @@ -1672,7 +1517,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 +1525,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: @@ -1692,7 +1537,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) default: WARN_ON_ONCE(1); } - list_del(&event_notifier->priv->node); + list_del(&event_notifier->priv->parent.node); kmem_cache_free(event_notifier_private_cache, event_notifier->priv); kmem_cache_free(event_notifier_cache, event_notifier); break; @@ -1702,6 +1547,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) } } +static struct lttng_kernel_id_tracker *get_tracker(struct lttng_kernel_session *session, enum tracker_type tracker_type) { @@ -1917,7 +1763,7 @@ int lttng_session_list_tracker_ids(struct lttng_kernel_session *session, struct seq_file *m; int file_fd, ret; - file_fd = lttng_get_unused_fd(); + file_fd = get_unused_fd_flags(0); if (file_fd < 0) { ret = file_fd; goto fd_error; @@ -1977,7 +1823,8 @@ int lttng_match_enabler_name(const char *desc_name, return 1; } -int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, +static +int lttng_desc_match_enabler_check(const struct lttng_kernel_event_desc *desc, struct lttng_event_enabler_common *enabler) { const char *desc_name, *enabler_name; @@ -2066,37 +1913,138 @@ int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, } } -static -int lttng_event_enabler_match_event(struct lttng_event_recorder_enabler *event_enabler, - struct lttng_kernel_event_recorder *event_recorder) +bool lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, + struct lttng_event_enabler_common *enabler) { - struct lttng_event_enabler_common *base_enabler = lttng_event_recorder_enabler_as_enabler( - event_enabler); + int ret; - if (base_enabler->event_param.instrumentation != event_recorder->priv->parent.instrumentation) - return 0; - if (lttng_desc_match_enabler(event_recorder->priv->parent.desc, base_enabler) - && event_recorder->chan == event_enabler->chan) - return 1; - else - return 0; + ret = lttng_desc_match_enabler_check(desc, enabler); + if (ret < 0) { + WARN_ON_ONCE(1); + return false; + } + return ret; } -static -int lttng_event_notifier_enabler_match_event_notifier(struct lttng_event_notifier_enabler *event_notifier_enabler, - struct lttng_kernel_event_notifier *event_notifier) +bool lttng_event_enabler_match_event(struct lttng_event_enabler_common *event_enabler, + struct lttng_kernel_event_common *event) { - struct lttng_event_enabler_common *base_enabler = lttng_event_notifier_enabler_as_enabler( - event_notifier_enabler); + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; - 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->parent.user_token) - return 1; - else - return 0; + 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); + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + if (lttng_desc_match_enabler(event->priv->desc, event_enabler) + && event_recorder->chan == event_recorder_enabler->chan) + return true; + else + return false; + } + 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 (lttng_desc_match_enabler(event->priv->desc, event_enabler) + && event_notifier->priv->group == event_notifier_enabler->group + && event->priv->user_token == event_enabler->user_token) + return true; + else + return false; + } + default: + WARN_ON_ONCE(1); + return false; + } +} + +bool lttng_event_enabler_desc_match_event(struct lttng_event_enabler_common *event_enabler, + const struct lttng_kernel_event_desc *desc, + struct lttng_kernel_event_common *event) +{ + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; + + 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); + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + if (event->priv->desc == desc && event_recorder->chan == event_recorder_enabler->chan) + return true; + else + return false; + } + 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 (event->priv->desc == desc + && event_notifier->priv->group == event_notifier_enabler->group + && event->priv->user_token == event_enabler->user_token) + return true; + else + return false; + } + default: + WARN_ON_ONCE(1); + return false; + } +} + +bool lttng_event_enabler_event_name_match_event(struct lttng_event_enabler_common *event_enabler, + const char *event_name, + struct lttng_kernel_event_common *event) +{ + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; + + 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); + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) + && event_recorder->chan == event_recorder_enabler->chan) + return true; + else + return false; + } + 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 (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) + && event_notifier->priv->group == event_notifier_enabler->group + && event->priv->user_token == event_enabler->user_token) + return true; + else + return false; + } + default: + WARN_ON_ONCE(1); + return false; + } } static @@ -2114,13 +2062,13 @@ struct lttng_enabler_ref *lttng_enabler_ref( } static -void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) +void lttng_event_enabler_create_tracepoint_events_if_missing(struct lttng_event_enabler_common *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); struct lttng_kernel_probe_desc *probe_desc; const struct lttng_kernel_event_desc *desc; - int i; struct list_head *probe_list; + int i; probe_list = lttng_get_probe_list_head(); /* @@ -2130,135 +2078,57 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enable */ list_for_each_entry(probe_desc, probe_list, head) { for (i = 0; i < probe_desc->nr_events; i++) { - int found = 0; + bool found = false; struct hlist_head *head; - struct lttng_kernel_event_recorder_private *event_recorder_private; - struct lttng_kernel_event_recorder *event_recorder; + struct lttng_kernel_event_common *event; + struct lttng_kernel_event_common_private *event_priv; desc = probe_desc->event_desc[i]; - if (!lttng_desc_match_enabler(desc, - lttng_event_recorder_enabler_as_enabler(event_enabler))) + if (!lttng_desc_match_enabler(desc, 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) - found = 1; + 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 (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub)) { + found = true; + break; + } } if (found) continue; /* - * We need to create an event for this - * event probe. + * We need to create an event for this event probe. */ - event_recorder = _lttng_kernel_event_recorder_create(event_enabler, desc); - if (!event_recorder) { + event = _lttng_kernel_event_create(event_enabler, desc); + if (IS_ERR(event)) { printk(KERN_INFO "LTTng: Unable to create event %s\n", - probe_desc->event_desc[i]->event_name); - } - } - } -} - -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_kernel_probe_desc *probe_desc; - const struct lttng_kernel_event_desc *desc; - int i; - struct list_head *probe_list; - - probe_list = lttng_get_probe_list_head(); - /* - * For each probe event, if we find that a probe event matches - * our enabler, create an associated lttng_event_notifier if not - * already present. - */ - list_for_each_entry(probe_desc, probe_list, head) { - 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; - - desc = probe_desc->event_desc[i]; - if (!lttng_desc_match_enabler(desc, - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler))) - continue; - - /* - * 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->parent.user_token) - found = 1; - } - if (found) - continue; - - /* - * We need to create a event_notifier for this event probe. - */ - event_notifier = _lttng_event_notifier_create(desc, - event_notifier_enabler->parent.user_token, - event_notifier_enabler->error_counter_index, - event_notifier_group, NULL, - LTTNG_KERNEL_ABI_TRACEPOINT); - if (IS_ERR(event_notifier)) { - printk(KERN_INFO "Unable to create event_notifier %s\n", - probe_desc->event_desc[i]->event_name); - } - } - } -} - -static -void lttng_create_syscall_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) -{ - int ret; - - ret = lttng_syscalls_register_event(event_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); + probe_desc->event_desc[i]->event_name); + } + } + } } /* - * Create struct lttng_kernel_event_recorder if it is missing and present in the list of - * tracepoint probes. + * Create event 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_recorder_enabler *event_enabler) +void lttng_event_enabler_create_events_if_missing(struct lttng_event_enabler_common *event_enabler) { - switch (event_enabler->parent.event_param.instrumentation) { + int ret; + + switch (event_enabler->event_param.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_create_tracepoint_event_if_missing(event_enabler); + lttng_event_enabler_create_tracepoint_events_if_missing(event_enabler); break; case LTTNG_KERNEL_ABI_SYSCALL: - lttng_create_syscall_event_if_missing(event_enabler); + ret = lttng_event_enabler_create_syscall_events_if_missing(event_enabler); + WARN_ON_ONCE(ret); break; default: @@ -2267,132 +2137,66 @@ void lttng_create_event_if_missing(struct lttng_event_recorder_enabler *event_en } } -/* - * 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; - - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - 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_table.syscall_all_exit, enabled); - } - - /* First ensure that probe events are created for this enabler. */ - lttng_create_event_if_missing(event_enabler); - - /* 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, event_recorder)) - 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); - } - return 0; + /* 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); } -/* - * Create struct lttng_kernel_event_notifier if it is missing and present in the list of - * tracepoint probes. - * Should be called with sessions mutex held. - */ static -void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler) +void lttng_event_enabler_init_event_capture(struct lttng_event_enabler_common *event_enabler, + struct lttng_kernel_event_common *event) { - switch (event_notifier_enabler->parent.event_param.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_create_tracepoint_event_notifier_if_missing(event_notifier_enabler); + 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); - case LTTNG_KERNEL_ABI_SYSCALL: - lttng_create_syscall_event_notifier_if_missing(event_notifier_enabler); + /* 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; - + } default: WARN_ON_ONCE(1); - break; } } /* - * 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); + struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler); + struct lttng_kernel_event_common_private *event_priv; - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) - WRITE_ONCE(event_notifier_group->syscall_table.syscall_all_exit, enabled); + lttng_syscall_table_set_wildcard_all(event_enabler); - } - - /* First ensure that probe event_notifiers are created for this enabler. */ - lttng_create_event_notifier_if_missing(event_notifier_enabler); + /* First ensure that probe events are created for this enabler. */ + lttng_event_enabler_create_events_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_notifier_enabler_match_event_notifier(event_notifier_enabler, event_notifier)) + 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. @@ -2402,25 +2206,12 @@ int lttng_event_notifier_enabler_ref_event_notifiers( if (!enabler_ref) return -ENOMEM; - enabler_ref->ref = lttng_event_notifier_enabler_as_enabler( - event_notifier_enabler); - list_add(&enabler_ref->node, - &event_notifier_priv->parent.enablers_ref_head); + enabler_ref->ref = event_enabler; + list_add(&enabler_ref->node, &event_priv->enablers_ref_head); } - /* - * Link filter bytecodes if not linked yet. - */ - lttng_enabler_link_bytecode(event_notifier_priv->parent.desc, - lttng_static_ctx, &event_notifier_priv->parent.filter_bytecode_runtime_head, - <tng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head); - - /* Link capture bytecodes if not linked yet. */ - lttng_enabler_link_bytecode(event_notifier_priv->parent.desc, - lttng_static_ctx, &event_notifier_priv->capture_bytecode_runtime_head, - &event_notifier_enabler->capture_bytecode_head); - - event_notifier_priv->num_captures = event_notifier_enabler->num_captures; + lttng_event_enabler_init_event_filter(event_enabler, event); + lttng_event_enabler_init_event_capture(event_enabler, event); } return 0; } @@ -2442,11 +2233,10 @@ int lttng_fix_pending_events(void) static bool lttng_event_notifier_group_has_active_event_notifiers( struct lttng_event_notifier_group *event_notifier_group) { - struct lttng_event_notifier_enabler *event_notifier_enabler; + struct lttng_event_enabler_common *event_enabler; - list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, - node) { - if (event_notifier_enabler->parent.enabled) + list_for_each_entry(event_enabler, &event_notifier_group->enablers_head, node) { + if (event_enabler->enabled) return true; } return false; @@ -2497,8 +2287,8 @@ void lttng_event_enabler_session_add(struct lttng_kernel_session *session, struct lttng_event_recorder_enabler *event_enabler) { mutex_lock(&sessions_mutex); - list_add(&event_enabler->node, &session->priv->enablers_head); - event_enabler->published = true; + list_add(&event_enabler->parent.node, &session->priv->enablers_head); + event_enabler->parent.published = true; lttng_session_lazy_sync_event_enablers(session); mutex_unlock(&sessions_mutex); } @@ -2594,15 +2384,16 @@ void lttng_enabler_destroy(struct lttng_event_enabler_common *enabler) void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enabler) { + lttng_enabler_destroy(event_enabler); + if (event_enabler->published) + list_del(&event_enabler->node); + switch (event_enabler->enabler_type) { case LTTNG_EVENT_ENABLER_TYPE_RECORDER: { struct lttng_event_recorder_enabler *event_recorder_enabler = container_of(event_enabler, struct lttng_event_recorder_enabler, parent); - lttng_enabler_destroy(event_enabler); - if (event_recorder_enabler->published) - list_del(&event_recorder_enabler->node); kfree(event_recorder_enabler); break; } @@ -2611,8 +2402,6 @@ void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enable struct lttng_event_notifier_enabler *event_notifier_enabler = container_of(event_enabler, struct lttng_event_notifier_enabler, parent); - list_del(&event_notifier_enabler->node); - lttng_enabler_destroy(event_enabler); kfree(event_notifier_enabler); break; } @@ -2622,9 +2411,9 @@ void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enable } 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; @@ -2646,34 +2435,17 @@ struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create( event_notifier_enabler->parent.enabled = 0; event_notifier_enabler->parent.user_token = event_notifier_param->event.token; event_notifier_enabler->group = event_notifier_group; - - mutex_lock(&sessions_mutex); - list_add(&event_notifier_enabler->node, &event_notifier_enabler->group->enablers_head); - lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); - - mutex_unlock(&sessions_mutex); - return event_notifier_enabler; } -int lttng_event_notifier_enabler_enable( - struct lttng_event_notifier_enabler *event_notifier_enabler) -{ - mutex_lock(&sessions_mutex); - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 1; - lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); - mutex_unlock(&sessions_mutex); - return 0; -} - -int lttng_event_notifier_enabler_disable( +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); - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0; + 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 0; } int lttng_event_notifier_enabler_attach_capture_bytecode( @@ -2718,90 +2490,169 @@ end: return ret; } +static +void lttng_event_sync_filter_state(struct lttng_kernel_event_common *event) +{ + int has_enablers_without_filter_bytecode = 0, nr_filters = 0; + struct lttng_kernel_bytecode_runtime *runtime; + struct lttng_enabler_ref *enabler_ref; + + /* Check if has enablers without bytecode enabled */ + list_for_each_entry(enabler_ref, &event->priv->enablers_ref_head, node) { + if (enabler_ref->ref->enabled + && list_empty(&enabler_ref->ref->filter_bytecode_head)) { + has_enablers_without_filter_bytecode = 1; + break; + } + } + event->priv->has_enablers_without_filter_bytecode = has_enablers_without_filter_bytecode; + + /* Enable filters */ + list_for_each_entry(runtime, &event->priv->filter_bytecode_runtime_head, node) { + lttng_bytecode_sync_state(runtime); + nr_filters++; + } + WRITE_ONCE(event->eval_filter, !(has_enablers_without_filter_bytecode || !nr_filters)); +} + +static +void lttng_event_sync_capture_state(struct lttng_kernel_event_common *event) +{ + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + break; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + { + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + struct lttng_kernel_bytecode_runtime *runtime; + int nr_captures = 0; + + /* Enable captures */ + list_for_each_entry(runtime, &event_notifier->priv->capture_bytecode_runtime_head, node) { + lttng_bytecode_sync_state(runtime); + nr_captures++; + } + WRITE_ONCE(event_notifier->eval_capture, !!nr_captures); + break; + } + default: + WARN_ON_ONCE(1); + } +} + +static +bool lttng_get_event_enabled_state(struct lttng_kernel_event_common *event) +{ + struct lttng_enabler_ref *enabler_ref; + bool enabled = false; + + switch (event->priv->instrumentation) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + /* Enable events */ + list_for_each_entry(enabler_ref, &event->priv->enablers_ref_head, node) { + if (enabler_ref->ref->enabled) { + enabled = true; + break; + } + } + break; + default: + WARN_ON_ONCE(1); + return false; + } + + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + { + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + /* + * Enabled state is based on union of enablers, with + * intersection of session and channel transient enable + * states. + */ + return enabled && event_recorder->chan->parent.session->priv->tstate && event_recorder->chan->priv->parent.tstate; + } + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + return enabled; + default: + WARN_ON_ONCE(1); + return false; + } +} + +static +bool lttng_event_is_lazy_sync(struct lttng_kernel_event_common *event) +{ + switch (event->priv->instrumentation) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + return true; + + default: + /* Not handled with lazy sync. */ + return false; + } +} + /* - * lttng_session_sync_event_enablers should be called just before starting a - * session. * Should be called with sessions mutex held. */ static -void lttng_session_sync_event_enablers(struct lttng_kernel_session *session) +void lttng_sync_event_list(struct list_head *event_enabler_list, + struct list_head *event_list) { - struct lttng_event_recorder_enabler *event_enabler; - struct lttng_kernel_event_recorder_private *event_recorder_priv; + struct lttng_kernel_event_common_private *event_priv; + struct lttng_event_enabler_common *event_enabler; - list_for_each_entry(event_enabler, &session->priv->enablers_head, node) + list_for_each_entry(event_enabler, event_enabler_list, node) lttng_event_enabler_ref_events(event_enabler); + /* * For each event, if at least one of its enablers is enabled, * 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) { - 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; - - switch (event_recorder_priv->parent.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_SYSCALL: - /* Enable events */ - list_for_each_entry(enabler_ref, - &event_recorder_priv->parent.enablers_ref_head, node) { - if (enabler_ref->ref->enabled) { - enabled = 1; - break; - } - } - break; + list_for_each_entry(event_priv, event_list, node) { + struct lttng_kernel_event_common *event = event_priv->pub; + bool enabled; - default: - /* Not handled with lazy sync. */ + if (!lttng_event_is_lazy_sync(event)) continue; - } - /* - * Enabled state is based on union of enablers, with - * intesection of session and channel transient enable - * states. - */ - enabled = enabled && session->priv->tstate && event_recorder->chan->priv->parent.tstate; - WRITE_ONCE(event_recorder->parent.enabled, enabled); + enabled = lttng_get_event_enabled_state(event); + WRITE_ONCE(event->enabled, enabled); /* - * Sync tracepoint registration with event enabled - * state. + * Sync tracepoint registration with event enabled state. */ if (enabled) { - register_event(event_recorder); + if (!event_priv->registered) + register_event(event); } else { - _lttng_event_unregister(event_recorder); - } - - /* 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; - } + if (event_priv->registered) + unregister_event(event); } - 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); + lttng_event_sync_capture_state(event); } } +/* + * 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) +{ + lttng_sync_event_list(&session->priv->enablers_head, &session->priv->events); +} + /* * Apply enablers to session events, adding events to session if need * be. It is required after each modification applied to an active @@ -2821,84 +2672,7 @@ void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session *session static void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group) { - struct lttng_event_notifier_enabler *event_notifier_enabler; - struct lttng_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); - - /* - * 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) { - 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; - - switch (event_notifier_priv->parent.instrumentation) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_SYSCALL: - /* Enable event_notifiers */ - list_for_each_entry(enabler_ref, - &event_notifier_priv->parent.enablers_ref_head, node) { - if (enabler_ref->ref->enabled) { - enabled = 1; - break; - } - } - break; - - default: - /* Not handled with sync. */ - continue; - } - - WRITE_ONCE(event_notifier->parent.enabled, enabled); - /* - * Sync tracepoint registration with event_notifier enabled - * state. - */ - if (enabled) { - if (!event_notifier_priv->parent.registered) - register_event_notifier(event_notifier); - } else { - if (event_notifier_priv->parent.registered) - _lttng_event_notifier_unregister(event_notifier); - } - - /* 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_sync_event_list(&event_notifier_group->enablers_head, &event_notifier_group->event_notifiers_head); } static @@ -3025,6 +2799,7 @@ void lttng_metadata_end(struct lttng_kernel_session *session) * The content of the printf is printed as a single atomic metadata * transaction. */ +static int lttng_metadata_printf(struct lttng_kernel_session *session, const char *fmt, ...) { @@ -3693,12 +3468,19 @@ int _lttng_fields_metadata_statedump(struct lttng_kernel_session *session, * transaction. */ static -int _lttng_event_metadata_statedump(struct lttng_kernel_session *session, - struct lttng_kernel_channel_buffer *chan, - struct lttng_kernel_event_recorder *event_recorder) +int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event) { + struct lttng_kernel_event_recorder *event_recorder; + struct lttng_kernel_channel_buffer *chan; + struct lttng_kernel_session *session; int ret = 0; + if (event->type != LTTNG_KERNEL_EVENT_TYPE_RECORDER) + return 0; + event_recorder = container_of(event, struct lttng_kernel_event_recorder, parent); + chan = event_recorder->chan; + session = chan->parent.session; + if (event_recorder->priv->metadata_dumped || !LTTNG_READ_ONCE(session->active)) return 0; if (chan->priv->channel_type == METADATA_CHANNEL) @@ -3882,20 +3664,12 @@ int64_t measure_clock_offset(void) uint64_t tcf = trace_clock_freq(); int64_t offset; unsigned long flags; -#ifdef LTTNG_KERNEL_HAS_TIMESPEC64 struct timespec64 rts = { 0, 0 }; -#else - struct timespec rts = { 0, 0 }; -#endif /* Disable interrupts to increase correlation precision. */ local_irq_save(flags); monotonic[0] = trace_clock_read64(); -#ifdef LTTNG_KERNEL_HAS_TIMESPEC64 ktime_get_real_ts64(&rts); -#else - getnstimeofday(&rts); -#endif monotonic[1] = trace_clock_read64(); local_irq_restore(flags); @@ -4152,9 +3926,8 @@ skip_session: goto end; } - list_for_each_entry(event_recorder_priv, &session->priv->events, node) { - ret = _lttng_event_metadata_statedump(session, event_recorder_priv->pub->chan, - event_recorder_priv->pub); + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { + ret = _lttng_event_recorder_metadata_statedump(&event_recorder_priv->pub->parent); if (ret) goto end; } @@ -4356,13 +4129,7 @@ static int __init lttng_events_init(void) { int ret; - ret = wrapper_lttng_fixup_sig(THIS_MODULE); - if (ret) - return ret; ret = wrapper_get_pfnblock_flags_mask_init(); - if (ret) - return ret; - ret = wrapper_get_pageblock_flags_mask_init(); if (ret) return ret; ret = lttng_probes_init();