#include <linux/seq_file.h>
#include <linux/file.h>
#include <linux/anon_inodes.h>
-#include <wrapper/file.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>
#include <linux/dmi.h>
#include <lttng/utils.h>
#include <ringbuffer/backend.h>
#include <ringbuffer/frontend.h>
-#include <wrapper/time.h>
+
+#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 <linux/stdarg.h>
+#else
+#include <stdarg.h>
+#endif
#define METADATA_CACHE_DEFAULT_SIZE 4096
static void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session *session);
static void lttng_session_sync_event_enablers(struct lttng_kernel_session *session);
-static void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler *event_notifier_enabler);
static void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group);
+static void lttng_event_enabler_sync(struct lttng_event_enabler_common *event_enabler);
static void _lttng_event_destroy(struct lttng_kernel_event_common *event);
static void _lttng_channel_destroy(struct lttng_kernel_channel_buffer *chan);
-static int _lttng_event_unregister(struct lttng_kernel_event_recorder *event);
-static int _lttng_event_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
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)
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);
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_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_enabler, tmp_event_enabler,
- &session->priv->enablers_head, 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, node)
+ list_for_each_entry_safe(event_recorder_priv, tmpevent_recorder_priv, &session->priv->events, parent.node)
_lttng_event_destroy(&event_recorder_priv->pub->parent);
list_for_each_entry_safe(chan_priv, tmpchan_priv, &session->priv->chan, node) {
BUG_ON(chan_priv->channel_type == METADATA_CHANNEL);
void lttng_event_notifier_group_destroy(
struct lttng_event_notifier_group *event_notifier_group)
{
- struct lttng_event_notifier_enabler *event_notifier_enabler, *tmp_event_notifier_enabler;
+ struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler;
struct lttng_kernel_event_notifier_private *event_notifier_priv, *tmpevent_notifier_priv;
int ret;
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->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_notifier_enabler_destroy(event_notifier_enabler);
+ lttng_event_enabler_destroy(event_enabler);
list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv,
- &event_notifier_group->event_notifiers_head, node)
+ &event_notifier_group->event_notifiers_head, parent.node)
_lttng_event_destroy(&event_notifier_priv->pub->parent);
if (event_notifier_group->error_counter) {
chan_priv->metadata_dumped = 0;
}
- list_for_each_entry(event_recorder_priv, &session->priv->events, node) {
+ list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
event_recorder_priv->metadata_dumped = 0;
}
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;
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,
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_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;
}
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;
}
* 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.
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.
*/
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;
}
* 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) {
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;
}
* 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
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;
+ ret = lttng_syscall_filter_disable_event(event);
+ break;
+
+ case LTTNG_KERNEL_ABI_NOOP:
+ switch (event->type) {
+ case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ ret = 0;
break;
- case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
- event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
+ case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+ WARN_ON_ONCE(1);
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;
- }
- 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;
- }
- }
-
- 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_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;
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);
}
/*
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:
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:
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;
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:
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:
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;
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;
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;
}
}
-static
-int lttng_event_enabler_match_event(struct lttng_event_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_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
}
static
-void lttng_create_tracepoint_event_if_missing(struct lttng_event_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;
-
- 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 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_recorder_private *event_recorder_private;
- struct lttng_kernel_event_recorder *event_recorder;
-
- desc = probe_desc->event_desc[i];
- if (!lttng_desc_match_enabler(desc,
- lttng_event_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)
- found = 1;
- }
- if (found)
- continue;
-
- /*
- * We need to create an event for this
- * event probe.
- */
- 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);
- }
- }
- }
-}
-
-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
+ * our enabler, create an associated lttng_event 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;
+ bool found = false;
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 *event;
+ struct lttng_kernel_event_common_private *event_priv;
desc = probe_desc->event_desc[i];
- if (!lttng_desc_match_enabler(desc,
- lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)))
+ if (!lttng_desc_match_enabler(desc, event_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;
+ 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 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_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);
-}
-
-/*
- * 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)
-{
- 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);
- break;
-
- default:
- WARN_ON_ONCE(1);
- break;
- }
-}
-
-/*
- * Create events associated with an event_enabler (if not already present),
- * and add backward reference from the event to the enabler.
- * Should be called with sessions mutex held.
- */
-static
-int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
-{
- 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_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_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);
- }
-
- /* 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_enabler_as_enabler(event_enabler));
- if (!enabler_ref) {
- /*
- * If no backward ref, create it.
- * Add backward ref from event to event_enabler.
+ * We need to create an event for this event probe.
*/
- enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
- if (!enabler_ref)
- return -ENOMEM;
- enabler_ref->ref = lttng_event_enabler_as_enabler(event_enabler);
- list_add(&enabler_ref->node,
- &event_recorder_priv->parent.enablers_ref_head);
+ 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);
+ }
}
-
- /*
- * 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_enabler_as_enabler(event_enabler)->filter_bytecode_head);
}
- return 0;
}
/*
- * Create struct lttng_kernel_event_notifier 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_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler)
+void lttng_event_enabler_create_events_if_missing(struct lttng_event_enabler_common *event_enabler)
{
- switch (event_notifier_enabler->parent.event_param.instrumentation) {
+ int ret;
+
+ switch (event_enabler->event_param.instrumentation) {
case LTTNG_KERNEL_ABI_TRACEPOINT:
- lttng_create_tracepoint_event_notifier_if_missing(event_notifier_enabler);
+ lttng_event_enabler_create_tracepoint_events_if_missing(event_enabler);
break;
case LTTNG_KERNEL_ABI_SYSCALL:
- lttng_create_syscall_event_notifier_if_missing(event_notifier_enabler);
+ ret = lttng_event_enabler_create_syscall_events_if_missing(event_enabler);
+ WARN_ON_ONCE(ret);
break;
default:
}
}
-/*
- * Create event_notifiers associated with a event_notifier enabler (if not already present).
- */
static
-int lttng_event_notifier_enabler_ref_event_notifiers(
- struct lttng_event_notifier_enabler *event_notifier_enabler)
+void lttng_event_enabler_init_event_filter(struct lttng_event_enabler_common *event_enabler,
+ struct lttng_kernel_event_common *event)
{
- 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, "*")) {
+ /* 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);
+}
- int enabled = base_enabler->enabled;
- enum lttng_kernel_abi_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit;
+static
+void lttng_event_enabler_init_event_capture(struct lttng_event_enabler_common *event_enabler,
+ struct lttng_kernel_event_common *event)
+{
+ switch (event_enabler->enabler_type) {
+ case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+ break;
+ case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
+ {
+ struct lttng_event_notifier_enabler *event_notifier_enabler =
+ container_of(event_enabler, struct lttng_event_notifier_enabler, parent);
+ struct lttng_kernel_event_notifier *event_notifier =
+ container_of(event, struct lttng_kernel_event_notifier, parent);
- if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT)
- WRITE_ONCE(event_notifier_group->syscall_all_entry, enabled);
+ /* Link capture bytecodes if not linked yet. */
+ lttng_enabler_link_bytecode(event->priv->desc,
+ lttng_static_ctx, &event_notifier->priv->capture_bytecode_runtime_head,
+ &event_notifier_enabler->capture_bytecode_head);
+ event_notifier->priv->num_captures = event_notifier_enabler->num_captures;
+ break;
+ }
+ default:
+ WARN_ON_ONCE(1);
+ }
+}
- if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT)
- WRITE_ONCE(event_notifier_group->syscall_all_exit, enabled);
+/*
+ * 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_enabler_common *event_enabler)
+{
+ struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler);
+ struct lttng_kernel_event_common_private *event_priv;
- }
+ lttng_syscall_table_set_wildcard_all(event_enabler);
- /* First ensure that probe event_notifiers are created for this enabler. */
- lttng_create_event_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.
if (!enabler_ref)
return -ENOMEM;
- enabler_ref->ref = lttng_event_notifier_enabler_as_enabler(
- event_notifier_enabler);
- list_add(&enabler_ref->node,
- &event_notifier_priv->parent.enablers_ref_head);
+ enabler_ref->ref = event_enabler;
+ list_add(&enabler_ref->node, &event_priv->enablers_ref_head);
}
- /*
- * Link filter bytecodes if not linked yet.
- */
- lttng_enabler_link_bytecode(event_notifier_priv->parent.desc,
- lttng_static_ctx, &event_notifier_priv->parent.filter_bytecode_runtime_head,
- <tng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head);
-
- /* Link capture bytecodes if not linked yet. */
- lttng_enabler_link_bytecode(event_notifier_priv->parent.desc,
- lttng_static_ctx, &event_notifier_priv->capture_bytecode_runtime_head,
- &event_notifier_enabler->capture_bytecode_head);
-
- event_notifier_priv->num_captures = event_notifier_enabler->num_captures;
+ lttng_event_enabler_init_event_filter(event_enabler, event);
+ lttng_event_enabler_init_event_capture(event_enabler, event);
}
return 0;
}
static bool lttng_event_notifier_group_has_active_event_notifiers(
struct lttng_event_notifier_group *event_notifier_group)
{
- struct lttng_event_notifier_enabler *event_notifier_enabler;
+ struct lttng_event_enabler_common *event_enabler;
- list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head,
- node) {
- if (event_notifier_enabler->parent.enabled)
+ list_for_each_entry(event_enabler, &event_notifier_group->enablers_head, node) {
+ if (event_enabler->enabled)
return true;
}
return false;
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->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,
}
void lttng_event_enabler_session_add(struct lttng_kernel_session *session,
- struct lttng_event_enabler *event_enabler)
+ 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);
}
-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;
}
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:
}
}
-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));
-
+ lttng_enabler_destroy(event_enabler);
if (event_enabler->published)
list_del(&event_enabler->node);
- kfree(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);
+
+ 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);
+
+ 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;
if (!event_notifier_enabler)
return NULL;
+ 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->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);
+ 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 event_notifier_enabler;
}
int lttng_event_notifier_enabler_enable(
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)
}
static
-void lttng_event_notifier_enabler_destroy(
- struct lttng_event_notifier_enabler *event_notifier_enabler)
+void lttng_event_sync_filter_state(struct lttng_kernel_event_common *event)
{
- if (!event_notifier_enabler) {
- return;
+ 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;
}
+}
- list_del(&event_notifier_enabler->node);
+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;
- lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
- kfree(event_notifier_enabler);
+ 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_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
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));
+ lttng_sync_event_list(&event_notifier_group->enablers_head, &event_notifier_group->event_notifiers_head);
+}
- /* 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);
+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);
}
}
* 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)
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);
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;
}
{
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();
projects / lttng-modules.git / blobdiff