#include <lttng/endian.h>
#include <lttng/string-utils.h>
#include <lttng/utils.h>
+#include <counter/counter.h>
#include <ringbuffer/backend.h>
#include <ringbuffer/frontend.h>
-#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,16,0))
+#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>
static DEFINE_MUTEX(sessions_mutex);
static struct kmem_cache *event_recorder_cache;
static struct kmem_cache *event_recorder_private_cache;
+static struct kmem_cache *event_counter_cache;
+static struct kmem_cache *event_counter_private_cache;
static struct kmem_cache *event_notifier_cache;
static struct kmem_cache *event_notifier_private_cache;
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 void _lttng_channel_destroy(struct lttng_kernel_channel_common *chan);
static void _lttng_event_unregister(struct lttng_kernel_event_common *event);
static
int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event);
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)
{
struct lttng_kernel_session_private *iter;
- list_for_each_entry(iter, &sessions, list) {
+ list_for_each_entry(iter, &sessions, node) {
if (iter->pub->active)
return 1;
}
session->priv = session_priv;
session_priv->pub = session;
- INIT_LIST_HEAD(&session_priv->chan);
- INIT_LIST_HEAD(&session_priv->events);
+ INIT_LIST_HEAD(&session_priv->chan_head);
+ INIT_LIST_HEAD(&session_priv->events_head);
lttng_guid_gen(&session_priv->uuid);
metadata_cache = kzalloc(sizeof(struct lttng_metadata_cache),
sizeof(metadata_cache->uuid));
INIT_LIST_HEAD(&session_priv->enablers_head);
for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
- INIT_HLIST_HEAD(&session_priv->events_ht.table[i]);
- list_add(&session_priv->list, &sessions);
+ INIT_HLIST_HEAD(&session_priv->events_name_ht.table[i]);
+ for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
+ INIT_HLIST_HEAD(&session_priv->events_key_ht.table[i]);
+ list_add(&session_priv->node, &sessions);
if (lttng_id_tracker_init(&session->pid_tracker, session, TRACKER_PID))
goto tracker_alloc_error;
return NULL;
}
-struct lttng_counter *lttng_kernel_counter_create(
+struct lttng_kernel_channel_counter *lttng_kernel_counter_create(
const char *counter_transport_name,
- size_t number_dimensions, const size_t *dimensions_sizes)
+ size_t number_dimensions,
+ const struct lttng_kernel_counter_dimension *dimensions,
+ int64_t global_sum_step,
+ bool coalesce_hits)
{
- struct lttng_counter *counter = NULL;
struct lttng_counter_transport *counter_transport = NULL;
+ struct lttng_kernel_channel_counter *counter = NULL;
counter_transport = lttng_counter_transport_find(counter_transport_name);
if (!counter_transport) {
goto notransport;
}
- counter = lttng_kvzalloc(sizeof(struct lttng_counter), GFP_KERNEL);
+ counter = counter_transport->ops.priv->counter_create(number_dimensions, dimensions,
+ global_sum_step);
if (!counter)
- goto nomem;
+ goto create_error;
/* Create event notifier error counter. */
counter->ops = &counter_transport->ops;
- counter->transport = counter_transport;
-
- counter->counter = counter->ops->counter_create(
- number_dimensions, dimensions_sizes, 0);
- if (!counter->counter) {
- goto create_error;
- }
+ counter->priv->parent.coalesce_hits = coalesce_hits;
+ counter->priv->transport = counter_transport;
+ mutex_init(&counter->priv->map.lock);
return counter;
create_error:
- lttng_kvfree(counter);
-nomem:
if (counter_transport)
module_put(counter_transport->owner);
notransport:
return NULL;
}
+static
+void lttng_kernel_counter_destroy(struct lttng_kernel_channel_counter *counter)
+{
+ struct lttng_counter_transport *counter_transport = counter->priv->transport;
+
+ lttng_kvfree(counter->priv->map.descriptors);
+ counter->ops->priv->counter_destroy(counter);
+ module_put(counter_transport->owner);
+}
+
struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
{
struct lttng_transport *transport = NULL;
INIT_LIST_HEAD(&event_notifier_group->enablers_head);
INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head);
for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
- INIT_HLIST_HEAD(&event_notifier_group->events_ht.table[i]);
+ INIT_HLIST_HEAD(&event_notifier_group->events_name_ht.table[i]);
list_add(&event_notifier_group->node, &event_notifier_groups);
void lttng_session_destroy(struct lttng_kernel_session *session)
{
- struct lttng_kernel_channel_buffer_private *chan_priv, *tmpchan_priv;
+ struct lttng_kernel_channel_common_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_common *event_enabler, *tmp_event_enabler;
mutex_lock(&sessions_mutex);
WRITE_ONCE(session->active, 0);
- list_for_each_entry(chan_priv, &session->priv->chan, node) {
- ret = lttng_syscalls_unregister_syscall_table(&chan_priv->parent.syscall_table);
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ ret = lttng_syscalls_unregister_syscall_table(&chan_priv->syscall_table);
WARN_ON(ret);
}
- list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node)
+ list_for_each_entry(event_recorder_priv, &session->priv->events_head, parent.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_syscall_table(&chan_priv->parent.syscall_table);
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ ret = lttng_syscalls_destroy_syscall_table(&chan_priv->syscall_table);
WARN_ON(ret);
}
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)
+ list_for_each_entry_safe(event_recorder_priv, tmpevent_recorder_priv, &session->priv->events_head, parent.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);
+ list_for_each_entry_safe(chan_priv, tmpchan_priv, &session->priv->chan_head, node) {
_lttng_channel_destroy(chan_priv->pub);
}
mutex_lock(&session->priv->metadata_cache->lock);
- list_for_each_entry(metadata_stream, &session->priv->metadata_cache->metadata_stream, list)
+ list_for_each_entry(metadata_stream, &session->priv->metadata_cache->metadata_stream, node)
_lttng_metadata_channel_hangup(metadata_stream);
mutex_unlock(&session->priv->metadata_cache->lock);
lttng_id_tracker_fini(&session->pid_tracker);
lttng_id_tracker_fini(&session->gid_tracker);
lttng_id_tracker_fini(&session->vgid_tracker);
kref_put(&session->priv->metadata_cache->refcount, metadata_cache_destroy);
- list_del(&session->priv->list);
+ list_del(&session->priv->node);
mutex_unlock(&sessions_mutex);
lttng_kvfree(session->priv);
lttng_kvfree(session);
&event_notifier_group->event_notifiers_head, parent.node)
_lttng_event_destroy(&event_notifier_priv->pub->parent);
- if (event_notifier_group->error_counter) {
- struct lttng_counter *error_counter = event_notifier_group->error_counter;
-
- error_counter->ops->counter_destroy(error_counter->counter);
- module_put(error_counter->transport->owner);
- lttng_kvfree(error_counter);
- event_notifier_group->error_counter = NULL;
- }
+ if (event_notifier_group->error_counter)
+ lttng_kernel_counter_destroy(event_notifier_group->error_counter);
event_notifier_group->ops->priv->channel_destroy(event_notifier_group->chan);
module_put(event_notifier_group->transport->owner);
int lttng_session_enable(struct lttng_kernel_session *session)
{
int ret = 0;
- struct lttng_kernel_channel_buffer_private *chan_priv;
+ struct lttng_kernel_channel_common_private *chan_priv;
mutex_lock(&sessions_mutex);
if (session->active) {
* Snapshot the number of events per channel to know the type of header
* we need to use.
*/
- list_for_each_entry(chan_priv, &session->priv->chan, node) {
- if (chan_priv->header_type)
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ struct lttng_kernel_channel_buffer_private *chan_buf_priv;
+
+ if (chan_priv->pub->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER)
+ continue;
+ chan_buf_priv = container_of(chan_priv, struct lttng_kernel_channel_buffer_private, parent);
+ if (chan_buf_priv->header_type)
continue; /* don't change it if session stop/restart */
- if (chan_priv->free_event_id < 31)
- chan_priv->header_type = 1; /* compact */
+ if (chan_buf_priv->free_event_id < 31)
+ chan_buf_priv->header_type = 1; /* compact */
else
- chan_priv->header_type = 2; /* large */
+ chan_buf_priv->header_type = 2; /* large */
}
/* Clear each stream's quiescent state. */
- list_for_each_entry(chan_priv, &session->priv->chan, node) {
- if (chan_priv->channel_type != METADATA_CHANNEL)
- lib_ring_buffer_clear_quiescent_channel(chan_priv->rb_chan);
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ struct lttng_kernel_channel_buffer_private *chan_buf_priv;
+
+ if (chan_priv->pub->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER)
+ continue;
+ chan_buf_priv = container_of(chan_priv, struct lttng_kernel_channel_buffer_private, parent);
+ if (chan_buf_priv->channel_type != METADATA_CHANNEL)
+ lib_ring_buffer_clear_quiescent_channel(chan_buf_priv->rb_chan);
}
WRITE_ONCE(session->active, 1);
int lttng_session_disable(struct lttng_kernel_session *session)
{
int ret = 0;
- struct lttng_kernel_channel_buffer_private *chan_priv;
+ struct lttng_kernel_channel_common_private *chan_priv;
mutex_lock(&sessions_mutex);
if (!session->active) {
lttng_session_sync_event_enablers(session);
/* Set each stream's quiescent state. */
- list_for_each_entry(chan_priv, &session->priv->chan, node) {
- if (chan_priv->channel_type != METADATA_CHANNEL)
- lib_ring_buffer_set_quiescent_channel(chan_priv->rb_chan);
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ struct lttng_kernel_channel_buffer_private *chan_buf_priv;
+
+ if (chan_priv->pub->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER)
+ continue;
+ chan_buf_priv = container_of(chan_priv, struct lttng_kernel_channel_buffer_private, parent);
+ if (chan_buf_priv->channel_type != METADATA_CHANNEL)
+ lib_ring_buffer_set_quiescent_channel(chan_buf_priv->rb_chan);
}
end:
mutex_unlock(&sessions_mutex);
int lttng_session_metadata_regenerate(struct lttng_kernel_session *session)
{
int ret = 0;
- struct lttng_kernel_channel_buffer_private *chan_priv;
+ struct lttng_kernel_channel_common_private *chan_priv;
struct lttng_kernel_event_recorder_private *event_recorder_priv;
struct lttng_metadata_cache *cache = session->priv->metadata_cache;
struct lttng_metadata_stream *stream;
memset(cache->data, 0, cache->cache_alloc);
cache->metadata_written = 0;
cache->version++;
- list_for_each_entry(stream, &session->priv->metadata_cache->metadata_stream, list) {
+ list_for_each_entry(stream, &session->priv->metadata_cache->metadata_stream, node) {
stream->metadata_out = 0;
stream->metadata_in = 0;
}
mutex_unlock(&cache->lock);
session->priv->metadata_dumped = 0;
- list_for_each_entry(chan_priv, &session->priv->chan, node) {
- chan_priv->metadata_dumped = 0;
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ struct lttng_kernel_channel_buffer_private *chan_buf_priv;
+
+ if (chan_priv->pub->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER)
+ continue;
+ chan_buf_priv = container_of(chan_priv, struct lttng_kernel_channel_buffer_private, parent);
+ chan_buf_priv->metadata_dumped = 0;
}
- list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
+ list_for_each_entry(event_recorder_priv, &session->priv->events_head, parent.parent.node) {
event_recorder_priv->metadata_dumped = 0;
}
break;
}
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
- switch (event->priv->instrumentation) {
- case LTTNG_KERNEL_ABI_KRETPROBE:
- ret = -EINVAL;
- goto end;
- default:
- break;
- }
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
break;
default:
break;
case LTTNG_KERNEL_ABI_TRACEPOINT:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_SYSCALL:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
ret = -EINVAL;
break;
- case LTTNG_KERNEL_ABI_KPROBE:
- lttng_fallthrough;
case LTTNG_KERNEL_ABI_UPROBE:
WRITE_ONCE(event->enabled, 1);
break;
- case LTTNG_KERNEL_ABI_KRETPROBE:
- ret = lttng_kretprobes_event_enable_state(event, 1);
- break;
-
case LTTNG_KERNEL_ABI_FUNCTION:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_NOOP:
break;
}
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
- switch (event->priv->instrumentation) {
- case LTTNG_KERNEL_ABI_KRETPROBE:
- ret = -EINVAL;
- goto end;
- default:
- break;
- }
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
break;
default:
break;
case LTTNG_KERNEL_ABI_TRACEPOINT:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_SYSCALL:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
ret = -EINVAL;
break;
- case LTTNG_KERNEL_ABI_KPROBE:
- lttng_fallthrough;
case LTTNG_KERNEL_ABI_UPROBE:
WRITE_ONCE(event->enabled, 0);
break;
- case LTTNG_KERNEL_ABI_KRETPROBE:
- ret = lttng_kretprobes_event_enable_state(event, 0);
- break;
-
case LTTNG_KERNEL_ABI_FUNCTION:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_NOOP:
enum channel_type channel_type)
{
struct lttng_kernel_channel_buffer *chan;
- struct lttng_kernel_channel_buffer_private *chan_priv;
struct lttng_transport *transport = NULL;
mutex_lock(&sessions_mutex);
printk(KERN_WARNING "LTTng: Can't lock transport module.\n");
goto notransport;
}
- chan = kzalloc(sizeof(struct lttng_kernel_channel_buffer), GFP_KERNEL);
+ chan = lttng_kernel_alloc_channel_buffer();
if (!chan)
goto nomem;
- chan_priv = kzalloc(sizeof(struct lttng_kernel_channel_buffer_private), GFP_KERNEL);
- if (!chan_priv)
- goto nomem_priv;
- chan->priv = chan_priv;
- chan_priv->pub = chan;
- chan->parent.type = LTTNG_KERNEL_CHANNEL_TYPE_BUFFER;
chan->parent.session = session;
chan->priv->id = session->priv->free_chan_id++;
chan->ops = &transport->ops;
chan->parent.enabled = 1;
chan->priv->transport = transport;
chan->priv->channel_type = channel_type;
- list_add(&chan->priv->node, &session->priv->chan);
+ list_add(&chan->priv->parent.node, &session->priv->chan_head);
mutex_unlock(&sessions_mutex);
return chan;
create_error:
- kfree(chan_priv);
-nomem_priv:
- kfree(chan);
+ lttng_kernel_free_channel_common(&chan->parent);
nomem:
if (transport)
module_put(transport->owner);
* Needs to be called with sessions mutex held.
*/
static
-void _lttng_channel_destroy(struct lttng_kernel_channel_buffer *chan)
+void lttng_kernel_buffer_destroy(struct lttng_kernel_channel_buffer *chan)
{
chan->ops->priv->channel_destroy(chan->priv->rb_chan);
module_put(chan->priv->transport->owner);
- list_del(&chan->priv->node);
lttng_kernel_destroy_context(chan->priv->ctx);
kfree(chan->priv);
kfree(chan);
}
-void lttng_metadata_channel_destroy(struct lttng_kernel_channel_buffer *chan)
+static
+void _lttng_channel_destroy(struct lttng_kernel_channel_common *chan)
+{
+ list_del(&chan->priv->node);
+
+ switch (chan->type) {
+ case LTTNG_KERNEL_CHANNEL_TYPE_BUFFER:
+ {
+ struct lttng_kernel_channel_buffer *chan_buf =
+ container_of(chan, struct lttng_kernel_channel_buffer, parent);
+ lttng_kernel_buffer_destroy(chan_buf);
+ break;
+ }
+ case LTTNG_KERNEL_CHANNEL_TYPE_COUNTER:
+ {
+ struct lttng_kernel_channel_counter *chan_counter =
+ container_of(chan, struct lttng_kernel_channel_counter, parent);
+ lttng_kernel_counter_destroy(chan_counter);
+ break;
+ }
+ default:
+ WARN_ON_ONCE(1);
+ }
+}
+
+void lttng_metadata_channel_buffer_destroy(struct lttng_kernel_channel_buffer *chan)
{
BUG_ON(chan->priv->channel_type != METADATA_CHANNEL);
/* Protect the metadata cache with the sessions_mutex. */
mutex_lock(&sessions_mutex);
- _lttng_channel_destroy(chan);
+ _lttng_channel_destroy(&chan->parent);
mutex_unlock(&sessions_mutex);
}
-EXPORT_SYMBOL_GPL(lttng_metadata_channel_destroy);
+EXPORT_SYMBOL_GPL(lttng_metadata_channel_buffer_destroy);
static
void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
{
struct lttng_event_recorder_enabler *event_recorder_enabler =
- container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
+ container_of(event_enabler, struct lttng_event_recorder_enabler, parent.parent);
struct lttng_kernel_channel_buffer *chan = event_recorder_enabler->chan;
switch (itype) {
return false;
}
}
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
+ {
+ struct lttng_event_counter_enabler *event_counter_enabler =
+ container_of(event_enabler, struct lttng_event_counter_enabler, parent.parent);
+ struct lttng_kernel_channel_counter *chan = event_counter_enabler->chan;
+ size_t nr_dimensions, max_nr_elem;
+
+ if (lttng_kernel_counter_get_nr_dimensions(chan, &nr_dimensions))
+ return false;
+ WARN_ON_ONCE(nr_dimensions != 1);
+ if (nr_dimensions != 1)
+ return false;
+ if (lttng_kernel_counter_get_max_nr_elem(chan, &max_nr_elem))
+ return false;
+ 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_index >= max_nr_elem)
+ return false;
+ return true;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ /* kretprobes require 2 event IDs. */
+ if (chan->priv->free_index + 1 >= max_nr_elem)
+ return false;
+ return true;
+ default:
+ WARN_ON_ONCE(1);
+ return false;
+ }
+ }
case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
return true;
default:
}
static
-struct lttng_kernel_event_common *lttng_kernel_event_alloc(struct lttng_event_enabler_common *event_enabler)
+struct lttng_kernel_event_common *lttng_kernel_event_alloc(struct lttng_event_enabler_common *event_enabler,
+ struct hlist_head *key_head,
+ const char *key_string)
{
struct lttng_kernel_abi_event *event_param = &event_enabler->event_param;
enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation;
case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
{
struct lttng_event_recorder_enabler *event_recorder_enabler =
- container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
+ container_of(event_enabler, struct lttng_event_recorder_enabler, parent.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;
+ WARN_ON_ONCE(key_head); /* not implemented. */
event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL);
if (!event_recorder)
return NULL;
return NULL;
}
event_recorder_priv->pub = event_recorder;
- event_recorder_priv->parent.pub = &event_recorder->parent;
+ event_recorder_priv->parent.parent.pub = &event_recorder->parent;
event_recorder->priv = event_recorder_priv;
- event_recorder->parent.priv = &event_recorder_priv->parent;
+ event_recorder->parent.priv = &event_recorder_priv->parent.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->priv->parent.parent.instrumentation = itype;
+ INIT_LIST_HEAD(&event_recorder->priv->parent.parent.filter_bytecode_runtime_head);
+ INIT_LIST_HEAD(&event_recorder->priv->parent.parent.enablers_ref_head);
event_recorder->chan = chan;
- event_recorder->priv->id = chan->priv->free_event_id++;
+ event_recorder->priv->parent.chan = &chan->parent;
+ event_recorder->priv->parent.id = chan->priv->free_event_id++;
return &event_recorder->parent;
}
case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
struct lttng_kernel_event_notifier *event_notifier;
struct lttng_kernel_event_notifier_private *event_notifier_priv;
+ WARN_ON_ONCE(key_head); /* not implemented. */
event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL);
if (!event_notifier)
return NULL;
INIT_LIST_HEAD(&event_notifier->priv->capture_bytecode_runtime_head);
return &event_notifier->parent;
}
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
+ {
+ struct lttng_event_counter_enabler *event_counter_enabler =
+ container_of(event_enabler, struct lttng_event_counter_enabler, parent.parent);
+ struct lttng_kernel_event_counter *event_counter;
+ struct lttng_kernel_event_counter_private *event_counter_priv;
+ struct lttng_kernel_channel_counter *chan = event_counter_enabler->chan;
+ bool key_found = false;
+
+ event_counter = kmem_cache_zalloc(event_counter_cache, GFP_KERNEL);
+ if (!event_counter)
+ return NULL;
+ event_counter_priv = kmem_cache_zalloc(event_counter_private_cache, GFP_KERNEL);
+ if (!event_counter_priv) {
+ kmem_cache_free(event_counter_private_cache, event_counter);
+ return NULL;
+ }
+ event_counter_priv->pub = event_counter;
+ event_counter_priv->parent.parent.pub = &event_counter->parent;
+ event_counter->priv = event_counter_priv;
+ event_counter->parent.priv = &event_counter_priv->parent.parent;
+
+ event_counter->parent.type = LTTNG_KERNEL_EVENT_TYPE_COUNTER;
+ event_counter->parent.run_filter = lttng_kernel_interpret_event_filter;
+ event_counter->priv->parent.parent.instrumentation = itype;
+ INIT_LIST_HEAD(&event_counter->priv->parent.parent.filter_bytecode_runtime_head);
+ INIT_LIST_HEAD(&event_counter->priv->parent.parent.enablers_ref_head);
+
+ event_counter->chan = chan;
+ event_counter->priv->parent.chan = &chan->parent;
+ if (!chan->priv->parent.coalesce_hits)
+ event_counter->priv->parent.parent.user_token = event_counter_enabler->parent.parent.user_token;
+ strcpy(event_counter_priv->key, key_string);
+ event_counter_priv->action = event_counter_enabler->action;
+ if (key_head) {
+ struct lttng_kernel_event_counter_private *event_counter_priv_iter;
+
+ lttng_hlist_for_each_entry(event_counter_priv_iter, key_head, hlist_key_node) {
+ if (!strcmp(key_string, event_counter_priv_iter->key)) {
+ /* Same key, use same id. */
+ key_found = true;
+ event_counter->priv->parent.id = event_counter_priv_iter->parent.id;
+ break;
+ }
+ }
+ }
+ if (!key_found)
+ event_counter->priv->parent.id = chan->priv->free_index++;
+ return &event_counter->parent;
+ }
default:
return NULL;
}
kmem_cache_free(event_recorder_cache, event_recorder);
break;
}
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
+ {
+ struct lttng_kernel_event_counter *event_counter =
+ container_of(event, struct lttng_kernel_event_counter, parent);
+
+ kmem_cache_free(event_counter_private_cache, event_counter->priv);
+ kmem_cache_free(event_counter_cache, event_counter);
+ break;
+ }
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
{
struct lttng_kernel_event_notifier *event_notifier =
{
switch (event->type) {
case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
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_kernel_channel_counter *error_counter;
struct lttng_event_notifier_group *event_notifier_group = event_notifier->priv->group;
size_t dimension_index[1];
int ret;
}
dimension_index[0] = event_notifier->priv->error_counter_index;
- ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index);
+ ret = error_counter->ops->priv->counter_clear(error_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);
}
}
+int format_event_key(struct lttng_event_enabler_common *event_enabler, char *key_string,
+ const char *event_name)
+{
+ struct lttng_event_counter_enabler *event_counter_enabler;
+ const struct lttng_kernel_counter_key_dimension *dim;
+ size_t i, left = LTTNG_KERNEL_COUNTER_KEY_LEN;
+ const struct lttng_kernel_counter_key *key;
+
+ if (event_enabler->enabler_type != LTTNG_EVENT_ENABLER_TYPE_COUNTER)
+ return 0;
+ event_counter_enabler = container_of(event_enabler, struct lttng_event_counter_enabler, parent.parent);
+ key = event_counter_enabler->key;
+ if (!key->nr_dimensions)
+ return 0;
+ /* Currently event keys can only be specified on a single dimension. */
+ if (key->nr_dimensions != 1)
+ return -EINVAL;
+ dim = &key->dimension_array[0];
+ for (i = 0; i < dim->nr_key_tokens; i++) {
+ const struct lttng_key_token *token = &dim->token_array[i];
+ size_t token_len;
+ const char *str;
+
+ switch (token->type) {
+ case LTTNG_KEY_TOKEN_STRING:
+ str = token->str;
+ break;
+ case LTTNG_KEY_TOKEN_EVENT_NAME:
+ str = event_name;
+ break;
+ default:
+ return -EINVAL;
+ }
+ token_len = strlen(str);
+ if (token_len >= left)
+ return -EINVAL;
+ strcat(key_string, str);
+ left -= token_len;
+ }
+ return 0;
+}
+
+static
+bool match_event_key(struct lttng_kernel_event_common *event, const char *key_string)
+{
+ switch (event->type) {
+ case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+ return true;
+
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
+ {
+ struct lttng_kernel_event_counter_private *event_counter_priv =
+ container_of(event->priv, struct lttng_kernel_event_counter_private, parent.parent);
+
+ if (key_string[0] == '\0')
+ return true;
+ return !strcmp(key_string, event_counter_priv->key);
+ }
+
+ default:
+ WARN_ON_ONCE(1);
+ return false;
+ }
+}
+
+static
+bool match_event_session_token(struct lttng_kernel_event_session_common_private *event_session_priv,
+ uint64_t token)
+{
+ if (event_session_priv->chan->priv->coalesce_hits)
+ return true;
+ if (event_session_priv->parent.user_token == token)
+ return true;
+ return false;
+}
+
+bool lttng_event_enabler_event_name_key_match_event(struct lttng_event_enabler_common *event_enabler,
+ const char *event_name, const char *key_string, struct lttng_kernel_event_common *event)
+{
+ switch (event_enabler->enabler_type) {
+ case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
+ {
+ struct lttng_event_enabler_session_common *event_session_enabler =
+ container_of(event_enabler, struct lttng_event_enabler_session_common, parent);
+ struct lttng_kernel_event_session_common_private *event_session_priv =
+ container_of(event->priv, struct lttng_kernel_event_session_common_private, parent);
+ bool same_event = false, same_channel = false, same_key = false,
+ same_token = false;
+
+ WARN_ON_ONCE(!event->priv->desc);
+ if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1))
+ same_event = true;
+ if (event_session_enabler->chan == event_session_priv->chan) {
+ same_channel = true;
+ if (match_event_session_token(event_session_priv, event_enabler->user_token))
+ same_token = true;
+ }
+ if (match_event_key(event, key_string))
+ same_key = true;
+ return same_event && same_channel && same_key && same_token;
+ }
+
+ case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
+ {
+ /*
+ * Check if event_notifier already exists by checking
+ * if the event_notifier and enabler share the same
+ * description and id.
+ */
+ if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
+ && event->priv->user_token == event_enabler->user_token)
+ return true;
+ else
+ return false;
+ }
+ default:
+ WARN_ON_ONCE(1);
+ return false;
+ }
+}
+
+static
+int lttng_counter_append_descriptor(struct lttng_kernel_channel_counter *counter,
+ uint64_t user_token,
+ size_t index,
+ const char *key)
+{
+ struct lttng_counter_map *map = &counter->priv->map;
+ struct lttng_counter_map_descriptor *last;
+ int ret = 0;
+
+ if (strlen(key) >= LTTNG_KERNEL_COUNTER_KEY_LEN) {
+ WARN_ON_ONCE(1);
+ return -EOVERFLOW;
+ }
+ mutex_lock(&map->lock);
+ if (map->nr_descriptors == map->alloc_len) {
+ struct lttng_counter_map_descriptor *new_table, *old_table;
+ size_t old_len = map->nr_descriptors;
+ size_t new_len = max_t(size_t, old_len + 1, map->alloc_len * 2);
+
+ old_table = map->descriptors;
+ new_table = lttng_kvzalloc(sizeof(struct lttng_counter_map_descriptor) * new_len,
+ GFP_KERNEL);
+ if (!new_table) {
+ ret = -ENOMEM;
+ goto unlock;
+ }
+
+ if (old_table)
+ memcpy(new_table, old_table, old_len * sizeof(struct lttng_counter_map_descriptor));
+
+ map->descriptors = new_table;
+ map->alloc_len = new_len;
+ lttng_kvfree(old_table);
+ }
+ last = &map->descriptors[map->nr_descriptors++];
+ last->user_token = user_token;
+ last->array_index = index;
+ strcpy(last->key, key);
+unlock:
+ mutex_unlock(&map->lock);
+ return ret;
+}
+
+static
+int lttng_append_event_to_channel_map(struct lttng_event_enabler_common *event_enabler,
+ struct lttng_kernel_event_common *event,
+ const char *event_name)
+{
+ struct lttng_event_counter_enabler *event_counter_enabler;
+ struct lttng_kernel_channel_counter *chan_counter;
+ struct lttng_kernel_event_counter *event_counter;
+ const char *name = "<UNKNOWN>";
+
+ if (event_enabler->enabler_type != LTTNG_EVENT_ENABLER_TYPE_COUNTER)
+ return 0;
+ event_counter_enabler = container_of(event_enabler, struct lttng_event_counter_enabler, parent.parent);
+ event_counter = container_of(event, struct lttng_kernel_event_counter, parent);
+ chan_counter = event_counter_enabler->chan;
+ if (event_counter->priv->key[0])
+ name = event_counter->priv->key;
+ else
+ name = event_name;
+ return lttng_counter_append_descriptor(chan_counter, event_enabler->user_token,
+ event_counter->priv->parent.id, name);
+}
+
/*
* Supports event creation while tracing session is active.
* Needs to be called with sessions mutex held.
*/
struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler,
- const struct lttng_kernel_event_desc *event_desc)
+ const struct lttng_kernel_event_desc *event_desc,
+ struct lttng_kernel_event_pair *event_pair)
{
- struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler);
+ char key_string[LTTNG_KERNEL_COUNTER_KEY_LEN] = { 0 };
+ struct lttng_event_ht *events_name_ht = lttng_get_events_name_ht_from_enabler(event_enabler);
+ struct lttng_event_ht *events_key_ht = lttng_get_events_key_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_event_common_private *event_priv;
+ struct lttng_kernel_event_common_private *event_priv_iter;
struct lttng_kernel_event_common *event;
+ struct hlist_head *name_head, *key_head = NULL;
const char *event_name;
- struct hlist_head *head;
int ret;
- if (!lttng_kernel_event_id_available(event_enabler)) {
- ret = -EMFILE;
- goto full;
+ if (event_pair == NULL || event_pair->check_ids) {
+ if (!lttng_kernel_event_id_available(event_enabler)) {
+ ret = -EMFILE;
+ goto full;
+ }
}
switch (itype) {
lttng_fallthrough;
case LTTNG_KERNEL_ABI_UPROBE:
lttng_fallthrough;
- case LTTNG_KERNEL_ABI_KRETPROBE:
- lttng_fallthrough;
case LTTNG_KERNEL_ABI_SYSCALL:
event_name = event_param->name;
break;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ event_name = event_pair->name;
+ break;
+
case LTTNG_KERNEL_ABI_FUNCTION:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_NOOP:
goto type_error;
}
- 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)) {
+ if (format_event_key(event_enabler, key_string, event_name)) {
+ ret = -EINVAL;
+ goto type_error;
+ }
+
+ name_head = utils_borrow_hash_table_bucket(events_name_ht->table, LTTNG_EVENT_HT_SIZE, event_name);
+ lttng_hlist_for_each_entry(event_priv_iter, name_head, hlist_name_node) {
+ if (lttng_event_enabler_event_name_key_match_event(event_enabler,
+ event_name, key_string, event_priv_iter->pub)) {
ret = -EEXIST;
goto exist;
}
}
- event = lttng_kernel_event_alloc(event_enabler);
+ if (key_string[0] != '\0')
+ key_head = utils_borrow_hash_table_bucket(events_key_ht->table, LTTNG_EVENT_HT_SIZE, key_string);
+
+ event = lttng_kernel_event_alloc(event_enabler, key_head, key_string);
if (!event) {
ret = -ENOMEM;
goto alloc_error;
break;
case LTTNG_KERNEL_ABI_KPROBE:
- /*
- * Needs to be explicitly enabled after creation, since
- * we may want to apply filters.
- */
+ /* Event will be enabled by enabler sync. */
event->enabled = 0;
- event->priv->registered = 1;
- /*
- * Populate lttng_event structure before event
- * registration.
- */
- smp_wmb();
- ret = lttng_kprobes_register_event(event_name,
+ event->priv->registered = 0;
+ ret = lttng_kprobes_init_event(event_name,
event_param->u.kprobe.symbol_name,
event_param->u.kprobe.offset,
event_param->u.kprobe.addr,
ret = -EINVAL;
goto register_error;
}
+ /*
+ * Populate lttng_event structure before event
+ * registration.
+ */
+ smp_wmb();
ret = try_module_get(event->priv->desc->owner);
WARN_ON_ONCE(!ret);
break;
case LTTNG_KERNEL_ABI_KRETPROBE:
{
- 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 will be enabled by enabler sync. */
event->enabled = 0;
- event->priv->registered = 1;
-
- event_return = lttng_kernel_event_alloc(event_enabler);
- if (!event) {
- ret = -ENOMEM;
- goto alloc_error;
- }
-
- event_return->enabled = 0;
- event_return->priv->registered = 1;
-
- /*
- * Populate lttng_event structure before kretprobe registration.
- */
- smp_wmb();
- ret = lttng_kretprobes_register(event_name,
- event_param->u.kretprobe.symbol_name,
- event_param->u.kretprobe.offset,
- event_param->u.kretprobe.addr,
- event, event_return);
+ event->priv->registered = 0;
+ ret = lttng_kretprobes_init_event(event_name,
+ event_pair->entryexit,
+ event, event_pair->krp);
if (ret) {
- 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->priv->desc->owner);
WARN_ON_ONCE(!ret);
- ret = try_module_get(event_return->priv->desc->owner);
- WARN_ON_ONCE(!ret);
- ret = _lttng_event_recorder_metadata_statedump(event_return);
- WARN_ON_ONCE(ret > 0);
- if (ret) {
- 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_return->priv->node, event_list_head);
break;
}
case LTTNG_KERNEL_ABI_SYSCALL:
- /*
- * Needs to be explicitly enabled after creation, since
- * we may want to apply filters.
- */
+ /* Event will be enabled by enabler sync. */
event->enabled = 0;
event->priv->registered = 0;
event->priv->desc = event_desc;
goto register_error;
ret = try_module_get(event->priv->desc->owner);
WARN_ON_ONCE(!ret);
+ ret = lttng_append_event_to_channel_map(event_enabler, event, event_name);
+ WARN_ON_ONCE(ret);
break;
default:
}
ret = lttng_kernel_event_notifier_clear_error_counter(event);
- if (ret)
+ if (ret) {
goto register_error;
+ }
- hlist_add_head(&event->priv->hlist_node, head);
+ hlist_add_head(&event->priv->hlist_name_node, name_head);
+ if (key_head) {
+ struct lttng_kernel_event_counter_private *event_counter_priv =
+ container_of(event->priv, struct lttng_kernel_event_counter_private, parent.parent);
+ hlist_add_head(&event_counter_priv->hlist_key_node, key_head);
+ }
list_add(&event->priv->node, event_list_head);
return event;
}
struct lttng_kernel_event_common *lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler,
- const struct lttng_kernel_event_desc *event_desc)
+ const struct lttng_kernel_event_desc *event_desc,
+ struct lttng_kernel_event_pair *event_pair)
{
struct lttng_kernel_event_common *event;
mutex_lock(&sessions_mutex);
- event = _lttng_kernel_event_create(event_enabler, event_desc);
+ event = _lttng_kernel_event_create(event_enabler, event_desc, event_pair);
mutex_unlock(&sessions_mutex);
return event;
}
-int lttng_kernel_counter_read(struct lttng_counter *counter,
+int lttng_kernel_counter_read(struct lttng_kernel_channel_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,
+ return counter->ops->priv->counter_read(counter, dim_indexes,
cpu, val, overflow, underflow);
}
-int lttng_kernel_counter_aggregate(struct lttng_counter *counter,
+int lttng_kernel_counter_aggregate(struct lttng_kernel_channel_counter *counter,
const size_t *dim_indexes, int64_t *val,
bool *overflow, bool *underflow)
{
- return counter->ops->counter_aggregate(counter->counter, dim_indexes,
+ return counter->ops->priv->counter_aggregate(counter, dim_indexes,
val, overflow, underflow);
}
-int lttng_kernel_counter_clear(struct lttng_counter *counter,
+int lttng_kernel_counter_clear(struct lttng_kernel_channel_counter *counter,
const size_t *dim_indexes)
{
- return counter->ops->counter_clear(counter->counter, dim_indexes);
+ return counter->ops->priv->counter_clear(counter, dim_indexes);
+}
+
+int lttng_kernel_counter_get_nr_dimensions(struct lttng_kernel_channel_counter *counter,
+ size_t *nr_dimensions)
+{
+ return counter->ops->priv->counter_get_nr_dimensions(counter, nr_dimensions);
+}
+
+int lttng_kernel_counter_get_max_nr_elem(struct lttng_kernel_channel_counter *counter,
+ size_t *max_nr_elem)
+{
+ return counter->ops->priv->counter_get_max_nr_elem(counter, max_nr_elem);
}
-/* Only used for tracepoints and system calls for now. */
+/* Used for tracepoints, system calls, and kprobe. */
static
void register_event(struct lttng_kernel_event_common *event)
{
break;
case LTTNG_KERNEL_ABI_KPROBE:
- lttng_fallthrough;
+ ret = lttng_kprobes_register_event(event);
+ break;
+
case LTTNG_KERNEL_ABI_UPROBE:
ret = 0;
break;
case LTTNG_KERNEL_ABI_KRETPROBE:
- switch (event->type) {
- case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
- ret = 0;
- break;
- case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
- WARN_ON_ONCE(1);
- break;
- }
+ ret = lttng_kretprobes_register_event(event);
break;
case LTTNG_KERNEL_ABI_FUNCTION:
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;
- }
+ lttng_kretprobes_unregister_event(event);
+ ret = 0;
break;
case LTTNG_KERNEL_ABI_SYSCALL:
case LTTNG_KERNEL_ABI_NOOP:
switch (event->type) {
case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
ret = 0;
break;
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
static
void _lttng_event_destroy(struct lttng_kernel_event_common *event)
{
- struct lttng_kernel_event_common_private *event_priv = event->priv;
struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
lttng_free_event_filter_runtime(event);
/* Free event enabler refs */
list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
- &event_priv->enablers_ref_head, node)
+ &event->priv->enablers_ref_head, node)
kfree(enabler_ref);
+ /* Remove from event list. */
+ list_del(&event->priv->node);
+ /* Remove from event hash table. */
+ hlist_del(&event->priv->hlist_name_node);
+
switch (event->type) {
- case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
{
- struct lttng_kernel_event_recorder *event_recorder =
- container_of(event, struct lttng_kernel_event_recorder, parent);
-
- switch (event_priv->instrumentation) {
- case LTTNG_KERNEL_ABI_TRACEPOINT:
- lttng_event_desc_put(event_priv->desc);
- break;
-
- case LTTNG_KERNEL_ABI_KPROBE:
- module_put(event_priv->desc->owner);
- 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->parent);
- break;
-
- case LTTNG_KERNEL_ABI_SYSCALL:
- break;
-
- case LTTNG_KERNEL_ABI_UPROBE:
- module_put(event_priv->desc->owner);
- lttng_uprobes_destroy_event_private(&event_recorder->parent);
- break;
-
- case LTTNG_KERNEL_ABI_FUNCTION:
- lttng_fallthrough;
- case LTTNG_KERNEL_ABI_NOOP:
- lttng_fallthrough;
- default:
- WARN_ON_ONCE(1);
- }
- 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);
+ struct lttng_kernel_event_counter_private *event_counter_priv =
+ container_of(event->priv, struct lttng_kernel_event_counter_private, parent.parent);
+ if (event_counter_priv->key[0] != '\0')
+ hlist_del(&event_counter_priv->hlist_key_node);
break;
}
+ case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ lttng_fallthrough;
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
- {
- struct lttng_kernel_event_notifier *event_notifier =
- container_of(event, struct lttng_kernel_event_notifier, parent);
+ break;
+ default:
+ WARN_ON_ONCE(1);
+ }
- switch (event_notifier->priv->parent.instrumentation) {
- case LTTNG_KERNEL_ABI_TRACEPOINT:
- lttng_event_desc_put(event_notifier->priv->parent.desc);
- break;
+ switch (event->priv->instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ lttng_event_desc_put(event->priv->desc);
+ break;
- case LTTNG_KERNEL_ABI_KPROBE:
- module_put(event_notifier->priv->parent.desc->owner);
- lttng_kprobes_destroy_event_private(&event_notifier->parent);
- break;
+ case LTTNG_KERNEL_ABI_KPROBE:
+ module_put(event->priv->desc->owner);
+ lttng_kprobes_destroy_event_private(event);
+ break;
- case LTTNG_KERNEL_ABI_SYSCALL:
- break;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ module_put(event->priv->desc->owner);
+ lttng_kretprobes_destroy_event_private(event);
+ break;
- case LTTNG_KERNEL_ABI_UPROBE:
- module_put(event_notifier->priv->parent.desc->owner);
- lttng_uprobes_destroy_event_private(&event_notifier->parent);
- break;
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ 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);
- }
- 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);
+ case LTTNG_KERNEL_ABI_UPROBE:
+ module_put(event->priv->desc->owner);
+ lttng_uprobes_destroy_event_private(event);
break;
- }
+
+ case LTTNG_KERNEL_ABI_FUNCTION:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_NOOP:
+ lttng_fallthrough;
default:
WARN_ON_ONCE(1);
}
+
+ lttng_kernel_event_free(event);
}
+static
struct lttng_kernel_id_tracker *get_tracker(struct lttng_kernel_session *session,
enum tracker_type tracker_type)
{
default:
return -EINVAL;
}
- switch (enabler->event_param.u.syscall.abi) {
- case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL:
+ switch (enabler->event_param.u.syscall.abi) {
+ case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL:
+ break;
+ case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE:
+ if (compat)
+ return 0;
+ break;
+ case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT:
+ if (!compat)
+ return 0;
+ break;
+ default:
+ return -EINVAL;
+ }
+ switch (enabler->event_param.u.syscall.match) {
+ case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME:
+ switch (enabler->format_type) {
+ case LTTNG_ENABLER_FORMAT_STAR_GLOB:
+ return lttng_match_enabler_star_glob(desc_name, enabler_name);
+ case LTTNG_ENABLER_FORMAT_NAME:
+ return lttng_match_enabler_name(desc_name, enabler_name);
+ default:
+ return -EINVAL;
+ }
+ break;
+ case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NR:
+ return -EINVAL; /* Not implemented. */
+ default:
+ return -EINVAL;
+ }
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE:
+ desc_name = desc->event_name;
+ switch (enabler->format_type) {
+ case LTTNG_ENABLER_FORMAT_STAR_GLOB:
+ return -EINVAL;
+ case LTTNG_ENABLER_FORMAT_NAME:
+ return lttng_match_enabler_name(desc_name, enabler_name);
+ default:
+ return -EINVAL;
+ }
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ {
+ char base_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN];
+ size_t base_name_len; /* includes \0 */
+ char *last_separator, *entryexit;
+
+ desc_name = desc->event_name;
+ last_separator = strrchr(desc_name, '_');
+ base_name_len = last_separator - desc_name + 1;
+ memcpy(base_name, desc_name, base_name_len);
+ base_name[base_name_len - 1] = '\0'; /* Replace '_' by '\0' */
+ entryexit = last_separator + 1;
+
+ if (!strcmp(entryexit, "entry")) {
+ entry = true;
+ } else if (!strcmp(entryexit, "exit")) {
+ /* Nothing to do. */
+ } else {
+ WARN_ON_ONCE(1);
+ return -EINVAL;
+ }
+
+ switch (enabler->event_param.u.kretprobe.entryexit) {
+ case LTTNG_KERNEL_ABI_KRETPROBE_ENTRYEXIT:
break;
- case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE:
- if (compat)
+ case LTTNG_KERNEL_ABI_KRETPROBE_ENTRY:
+ if (!entry)
return 0;
break;
- case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT:
- if (!compat)
+ case LTTNG_KERNEL_ABI_KRETPROBE_EXIT:
+ if (entry)
return 0;
break;
default:
return -EINVAL;
}
- switch (enabler->event_param.u.syscall.match) {
- case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME:
- switch (enabler->format_type) {
- case LTTNG_ENABLER_FORMAT_STAR_GLOB:
- return lttng_match_enabler_star_glob(desc_name, enabler_name);
- case LTTNG_ENABLER_FORMAT_NAME:
- return lttng_match_enabler_name(desc_name, enabler_name);
- default:
- return -EINVAL;
- }
- break;
- case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NR:
- return -EINVAL; /* Not implemented. */
+
+ switch (enabler->format_type) {
+ case LTTNG_ENABLER_FORMAT_STAR_GLOB:
+ return -EINVAL;
+ case LTTNG_ENABLER_FORMAT_NAME:
+ return lttng_match_enabler_name(base_name, enabler_name);
default:
return -EINVAL;
}
break;
+ }
default:
WARN_ON_ONCE(1);
return ret;
}
-bool lttng_event_enabler_match_event(struct lttng_event_enabler_common *event_enabler,
- struct lttng_kernel_event_common *event)
+static
+bool lttng_event_session_enabler_match_event_session(struct lttng_event_enabler_session_common *event_enabler_session,
+ struct lttng_kernel_event_session_common_private *event_session_priv)
{
- 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 (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);
+ if (lttng_desc_match_enabler(event_session_priv->parent.desc, &event_enabler_session->parent)
+ && event_session_priv->chan == event_enabler_session->chan
+ && match_event_session_token(event_session_priv, event_enabler_session->parent.user_token))
+ return true;
+ else
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)
+static
+int lttng_event_notifier_enabler_match_event_notifier(
+ struct lttng_event_notifier_enabler *event_notifier_enabler,
+ struct lttng_kernel_event_notifier_private *event_notifier_priv)
{
- 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);
+ int desc_matches = lttng_desc_match_enabler(event_notifier_priv->parent.desc,
+ lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
- 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;
- }
+ if (desc_matches && 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;
}
-bool lttng_event_enabler_event_name_match_event(struct lttng_event_enabler_common *event_enabler,
- const char *event_name,
+bool lttng_event_enabler_match_event(struct lttng_event_enabler_common *event_enabler,
struct lttng_kernel_event_common *event)
{
if (event_enabler->event_param.instrumentation != event->priv->instrumentation)
switch (event_enabler->enabler_type) {
case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
{
- 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;
+ struct lttng_event_enabler_session_common *event_enabler_session =
+ container_of(event_enabler, struct lttng_event_enabler_session_common, parent);
+ struct lttng_kernel_event_session_common_private *event_session_priv =
+ container_of(event->priv, struct lttng_kernel_event_session_common_private, parent);
+ return lttng_event_session_enabler_match_event_session(event_enabler_session, event_session_priv);
}
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;
+ struct lttng_kernel_event_notifier_private *event_notifier_priv =
+ container_of(event->priv, struct lttng_kernel_event_notifier_private, parent);
+ return lttng_event_notifier_enabler_match_event_notifier(event_notifier_enabler, event_notifier_priv);
}
default:
WARN_ON_ONCE(1);
static
void lttng_event_enabler_create_tracepoint_events_if_missing(struct lttng_event_enabler_common *event_enabler)
{
- 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;
struct list_head *probe_list;
*/
list_for_each_entry(probe_desc, probe_list, head) {
for (i = 0; i < probe_desc->nr_events; i++) {
- bool found = false;
- struct hlist_head *head;
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, event_enabler))
continue;
-
- /*
- * Check if already created.
- */
- 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.
*/
- event = _lttng_kernel_event_create(event_enabler, desc);
+ event = _lttng_kernel_event_create(event_enabler, desc, NULL);
if (IS_ERR(event)) {
+ /* Skip if already found. */
+ if (PTR_ERR(event) == -EEXIST)
+ continue;
printk(KERN_INFO "LTTng: Unable to create event %s\n",
probe_desc->event_desc[i]->event_name);
}
}
}
+/* Try to create the event associated with this kprobe enabler. */
+static
+void lttng_event_enabler_create_kprobe_event_if_missing(struct lttng_event_enabler_common *event_enabler)
+{
+ struct lttng_kernel_event_common *event;
+
+ event = _lttng_kernel_event_create(event_enabler, NULL, NULL);
+ if (IS_ERR(event)) {
+ if (PTR_ERR(event) != -EEXIST) {
+ printk(KERN_INFO "LTTng: Unable to create kprobe event %s\n",
+ event_enabler->event_param.name);
+ }
+ }
+}
+
+/* Try to create the event associated with this kretprobe enabler. */
+static
+void lttng_event_enabler_create_kretprobe_event_if_missing(struct lttng_event_enabler_common *event_enabler)
+{
+ struct lttng_kernel_abi_event *event_param = &event_enabler->event_param;
+ struct lttng_kernel_event_pair event_pair;
+ struct lttng_kernel_event_common *event;
+
+ if (strlen(event_param->name) + strlen("_entry") >= LTTNG_KERNEL_ABI_SYM_NAME_LEN) {
+ WARN_ON_ONCE(1);
+ return;
+ }
+
+ memset(&event_pair, 0, sizeof(event_pair));
+ event_pair.krp = lttng_kretprobes_create_krp(event_param->u.kretprobe.symbol_name,
+ event_param->u.kretprobe.offset, event_param->u.kretprobe.addr);
+ if (!event_pair.krp) {
+ WARN_ON_ONCE(1);
+ return;
+ }
+ strcpy(event_pair.name, event_enabler->event_param.name);
+ strcat(event_pair.name, "_entry");
+ event_pair.check_ids = true;
+ event_pair.entryexit = LTTNG_KRETPROBE_ENTRY;
+ event = _lttng_kernel_event_create(event_enabler, NULL, &event_pair);
+ if (IS_ERR(event)) {
+ if (PTR_ERR(event) != -EEXIST) {
+ printk(KERN_INFO "LTTng: Unable to create kretprobe event %s\n",
+ event_enabler->event_param.name);
+ }
+ }
+
+ strcpy(event_pair.name, event_enabler->event_param.name);
+ strcat(event_pair.name, "_exit");
+ event_pair.check_ids = false;
+ event_pair.entryexit = LTTNG_KRETPROBE_EXIT;
+ event = _lttng_kernel_event_create(event_enabler, NULL, &event_pair);
+ if (IS_ERR(event)) {
+ if (PTR_ERR(event) != -EEXIST) {
+ printk(KERN_INFO "LTTng: Unable to create kretprobe event %s\n",
+ event_enabler->event_param.name);
+ }
+ }
+
+ lttng_kretprobes_put_krp(event_pair.krp);
+}
+
/*
* Create event if it is missing and present in the list of tracepoint probes.
* Should be called with sessions mutex held.
WARN_ON_ONCE(ret);
break;
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_event_enabler_create_kprobe_event_if_missing(event_enabler);
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ lttng_event_enabler_create_kretprobe_event_if_missing(event_enabler);
+ break;
+
default:
WARN_ON_ONCE(1);
break;
{
switch (event_enabler->enabler_type) {
case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
break;
case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
{
struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler);
struct lttng_kernel_event_common_private *event_priv;
+ /*
+ * Only try to create events for enablers that are enabled, the user
+ * might still be attaching filter or exclusion to the event enabler.
+ */
+ if (!event_enabler->enabled)
+ goto end;
+
lttng_syscall_table_set_wildcard_all(event_enabler);
/* First ensure that probe events are created for this enabler. */
enabler_ref = lttng_enabler_ref(&event_priv->enablers_ref_head, event_enabler);
if (!enabler_ref) {
+ int ret;
+
/*
* If no backward ref, create it.
* Add backward ref from event_notifier to enabler.
enabler_ref->ref = event_enabler;
list_add(&enabler_ref->node, &event_priv->enablers_ref_head);
+
+ ret = lttng_append_event_to_channel_map(event_enabler, event,
+ event->priv->desc->event_name);
+ WARN_ON_ONCE(ret);
}
lttng_event_enabler_init_event_filter(event_enabler, event);
lttng_event_enabler_init_event_capture(event_enabler, event);
}
+end:
return 0;
}
{
struct lttng_kernel_session_private *session_priv;
- list_for_each_entry(session_priv, &sessions, list)
+ list_for_each_entry(session_priv, &sessions, node)
lttng_session_lazy_sync_event_enablers(session_priv->pub);
return 0;
}
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,
- sizeof(event_enabler->parent.event_param));
+ event_enabler->parent.parent.enabler_type = LTTNG_EVENT_ENABLER_TYPE_RECORDER;
+ event_enabler->parent.parent.format_type = format_type;
+ INIT_LIST_HEAD(&event_enabler->parent.parent.filter_bytecode_head);
+ memcpy(&event_enabler->parent.parent.event_param, event_param,
+ sizeof(event_enabler->parent.parent.event_param));
+ event_enabler->chan = chan;
+ event_enabler->parent.chan = &chan->parent;
+
+ /* ctx left NULL */
+ event_enabler->parent.parent.enabled = 0;
+ return event_enabler;
+}
+
+struct lttng_event_counter_enabler *lttng_event_counter_enabler_create(
+ enum lttng_enabler_format_type format_type,
+ struct lttng_kernel_abi_event *event_param,
+ struct lttng_kernel_counter_key *counter_key,
+ struct lttng_kernel_channel_counter *chan)
+{
+ struct lttng_event_counter_enabler *event_enabler;
+
+ event_enabler = kzalloc(sizeof(*event_enabler), GFP_KERNEL);
+ if (!event_enabler)
+ return NULL;
+ event_enabler->parent.parent.enabler_type = LTTNG_EVENT_ENABLER_TYPE_COUNTER;
+ event_enabler->parent.parent.format_type = format_type;
+ INIT_LIST_HEAD(&event_enabler->parent.parent.filter_bytecode_head);
+ memcpy(&event_enabler->parent.parent.event_param, event_param,
+ sizeof(event_enabler->parent.parent.event_param));
event_enabler->chan = chan;
+ event_enabler->parent.chan = &chan->parent;
+ if (create_counter_key_from_kernel(&event_enabler->key, counter_key)) {
+ kfree(event_enabler);
+ return NULL;
+ }
+
/* ctx left NULL */
- event_enabler->parent.enabled = 0;
+ event_enabler->parent.parent.enabled = 0;
+ event_enabler->parent.parent.user_token = event_param->token;
return event_enabler;
}
void lttng_event_enabler_session_add(struct lttng_kernel_session *session,
- struct lttng_event_recorder_enabler *event_enabler)
+ struct lttng_event_enabler_session_common *event_enabler)
{
mutex_lock(&sessions_mutex);
list_add(&event_enabler->parent.node, &session->priv->enablers_head);
case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
{
struct lttng_event_recorder_enabler *event_recorder_enabler =
- container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
+ container_of(event_enabler, struct lttng_event_recorder_enabler, parent.parent);
kfree(event_recorder_enabler);
break;
kfree(event_notifier_enabler);
break;
}
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
+ {
+ struct lttng_event_counter_enabler *event_counter_enabler =
+ container_of(event_enabler, struct lttng_event_counter_enabler, parent.parent);
+
+ destroy_counter_key(event_counter_enabler->key);
+ kfree(event_counter_enabler);
+ break;
+ }
default:
WARN_ON_ONCE(1);
}
mutex_unlock(&sessions_mutex);
}
-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(
- struct lttng_event_notifier_enabler *event_notifier_enabler)
-{
- mutex_lock(&sessions_mutex);
- lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0;
- lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
- mutex_unlock(&sessions_mutex);
- return 0;
-}
-
int lttng_event_notifier_enabler_attach_capture_bytecode(
struct lttng_event_notifier_enabler *event_notifier_enabler,
struct lttng_kernel_abi_capture_bytecode __user *bytecode)
{
switch (event->type) {
case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
break;
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
{
case LTTNG_KERNEL_ABI_TRACEPOINT:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_SYSCALL:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
/* Enable events */
list_for_each_entry(enabler_ref, &event->priv->enablers_ref_head, node) {
if (enabler_ref->ref->enabled) {
switch (event->type) {
case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
{
- struct lttng_kernel_event_recorder *event_recorder =
- container_of(event, struct lttng_kernel_event_recorder, parent);
+ struct lttng_kernel_event_session_common_private *event_session_common_priv =
+ container_of(event->priv, struct lttng_kernel_event_session_common_private, 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;
+ return enabled && event_session_common_priv->chan->session->priv->tstate && event_session_common_priv->chan->priv->tstate;
}
case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
return enabled;
case LTTNG_KERNEL_ABI_TRACEPOINT:
lttng_fallthrough;
case LTTNG_KERNEL_ABI_SYSCALL:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_ABI_KRETPROBE:
return true;
default:
static
void lttng_session_sync_event_enablers(struct lttng_kernel_session *session)
{
- lttng_sync_event_list(&session->priv->enablers_head, &session->priv->events);
+ lttng_sync_event_list(&session->priv->enablers_head, &session->priv->events_head);
}
/*
{
switch (event_enabler->enabler_type) {
case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+ lttng_fallthrough;
+ case LTTNG_EVENT_ENABLER_TYPE_COUNTER:
{
- 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);
+ struct lttng_event_enabler_session_common *event_enabler_session =
+ container_of(event_enabler, struct lttng_event_enabler_session_common, parent);
+ lttng_session_lazy_sync_event_enablers(event_enabler_session->chan->session);
break;
}
case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
if (atomic_dec_return(&session->priv->metadata_cache->producing) == 0) {
struct lttng_metadata_stream *stream;
- list_for_each_entry(stream, &session->priv->metadata_cache->metadata_stream, list)
+ list_for_each_entry(stream, &session->priv->metadata_cache->metadata_stream, node)
wake_up_interruptible(&stream->read_wait);
mutex_unlock(&session->priv->metadata_cache->lock);
}
* 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, ...)
{
struct lttng_kernel_event_recorder *event_recorder)
{
const char *prev_field_name = NULL;
- const struct lttng_kernel_event_desc *desc = event_recorder->priv->parent.desc;
+ const struct lttng_kernel_event_desc *desc = event_recorder->priv->parent.parent.desc;
int ret = 0;
int i;
ret = lttng_metadata_printf(session,
"event {\n"
" name = \"%s\";\n"
- " id = %u;\n"
+ " id = %llu;\n"
" stream_id = %u;\n",
- event_recorder->priv->parent.desc->event_name,
- event_recorder->priv->id,
+ event_recorder->priv->parent.parent.desc->event_name,
+ event_recorder->priv->parent.id,
event_recorder->chan->priv->id);
if (ret)
goto end;
unsigned char *uuid_c = session->priv->uuid.b;
unsigned char uuid_s[37], clock_uuid_s[BOOT_ID_LEN];
const char *product_uuid;
- struct lttng_kernel_channel_buffer_private *chan_priv;
+ struct lttng_kernel_channel_common_private *chan_priv;
struct lttng_kernel_event_recorder_private *event_recorder_priv;
int ret = 0;
goto end;
skip_session:
- list_for_each_entry(chan_priv, &session->priv->chan, node) {
- ret = _lttng_channel_metadata_statedump(session, chan_priv->pub);
+ list_for_each_entry(chan_priv, &session->priv->chan_head, node) {
+ struct lttng_kernel_channel_buffer_private *chan_buf_priv;
+
+ if (chan_priv->pub->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER)
+ continue;
+ chan_buf_priv = container_of(chan_priv, struct lttng_kernel_channel_buffer_private, parent);
+ ret = _lttng_channel_metadata_statedump(session, chan_buf_priv->pub);
if (ret)
goto end;
}
- list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
+ list_for_each_entry(event_recorder_priv, &session->priv->events_head, parent.parent.node) {
ret = _lttng_event_recorder_metadata_statedump(&event_recorder_priv->pub->parent);
if (ret)
goto end;
}
EXPORT_SYMBOL_GPL(lttng_counter_transport_unregister);
+struct lttng_kernel_channel_buffer *lttng_kernel_alloc_channel_buffer(void)
+{
+ struct lttng_kernel_channel_buffer *lttng_chan_buf;
+ struct lttng_kernel_channel_common *lttng_chan_common;
+ struct lttng_kernel_channel_buffer_private *lttng_chan_buf_priv;
+
+ lttng_chan_buf = kzalloc(sizeof(struct lttng_kernel_channel_buffer), GFP_KERNEL);
+ if (!lttng_chan_buf)
+ goto nomem;
+ lttng_chan_buf_priv = kzalloc(sizeof(struct lttng_kernel_channel_buffer_private), GFP_KERNEL);
+ if (!lttng_chan_buf_priv)
+ goto nomem_priv;
+ lttng_chan_common = <tng_chan_buf->parent;
+ lttng_chan_common->type = LTTNG_KERNEL_CHANNEL_TYPE_BUFFER;
+ lttng_chan_buf->priv = lttng_chan_buf_priv;
+ lttng_chan_common->priv = <tng_chan_buf_priv->parent;
+ lttng_chan_buf_priv->pub = lttng_chan_buf;
+ lttng_chan_buf_priv->parent.pub = lttng_chan_common;
+ return lttng_chan_buf;
+
+nomem_priv:
+ kfree(lttng_chan_buf);
+nomem:
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(lttng_kernel_alloc_channel_buffer);
+
+struct lttng_kernel_channel_counter *lttng_kernel_alloc_channel_counter(void)
+{
+ struct lttng_kernel_channel_counter *lttng_chan_counter;
+ struct lttng_kernel_channel_common *lttng_chan_common;
+ struct lttng_kernel_channel_counter_private *lttng_chan_counter_priv;
+
+ lttng_chan_counter = kzalloc(sizeof(struct lttng_kernel_channel_counter), GFP_KERNEL);
+ if (!lttng_chan_counter)
+ goto nomem;
+ lttng_chan_counter_priv = kzalloc(sizeof(struct lttng_kernel_channel_counter_private), GFP_KERNEL);
+ if (!lttng_chan_counter_priv)
+ goto nomem_priv;
+ lttng_chan_common = <tng_chan_counter->parent;
+ lttng_chan_common->type = LTTNG_KERNEL_CHANNEL_TYPE_COUNTER;
+ lttng_chan_counter->priv = lttng_chan_counter_priv;
+ lttng_chan_common->priv = <tng_chan_counter_priv->parent;
+ lttng_chan_counter_priv->pub = lttng_chan_counter;
+ lttng_chan_counter_priv->parent.pub = lttng_chan_common;
+ return lttng_chan_counter;
+
+nomem_priv:
+ kfree(lttng_chan_counter);
+nomem:
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(lttng_kernel_alloc_channel_counter);
+
+void lttng_kernel_free_channel_common(struct lttng_kernel_channel_common *chan)
+{
+ switch (chan->type) {
+ case LTTNG_KERNEL_CHANNEL_TYPE_BUFFER:
+ {
+ struct lttng_kernel_channel_buffer *chan_buf = container_of(chan,
+ struct lttng_kernel_channel_buffer, parent);
+
+ kfree(chan_buf->priv);
+ kfree(chan_buf);
+ break;
+ }
+ case LTTNG_KERNEL_CHANNEL_TYPE_COUNTER:
+ {
+ struct lttng_kernel_channel_counter *chan_counter = container_of(chan,
+ struct lttng_kernel_channel_counter, parent);
+
+ kfree(chan_counter->priv);
+ kfree(chan_counter);
+ break;
+ }
+ default:
+ WARN_ON_ONCE(1);
+ }
+}
+EXPORT_SYMBOL_GPL(lttng_kernel_free_channel_common);
+
#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0))
enum cpuhp_state lttng_hp_prepare;
ret = -ENOMEM;
goto error_kmem_event_recorder_private;
}
+ event_counter_cache = KMEM_CACHE(lttng_kernel_event_counter, 0);
+ if (!event_counter_cache) {
+ ret = -ENOMEM;
+ goto error_kmem_event_counter;
+ }
+ event_counter_private_cache = KMEM_CACHE(lttng_kernel_event_counter_private, 0);
+ if (!event_counter_private_cache) {
+ ret = -ENOMEM;
+ goto error_kmem_event_counter_private;
+ }
event_notifier_cache = KMEM_CACHE(lttng_kernel_event_notifier, 0);
if (!event_notifier_cache) {
ret = -ENOMEM;
error_kmem_event_notifier_private:
kmem_cache_destroy(event_notifier_cache);
error_kmem_event_notifier:
+ kmem_cache_destroy(event_counter_private_cache);
+error_kmem_event_counter_private:
+ kmem_cache_destroy(event_counter_cache);
+error_kmem_event_counter:
kmem_cache_destroy(event_recorder_private_cache);
error_kmem_event_recorder_private:
kmem_cache_destroy(event_recorder_cache);
lttng_exit_cpu_hotplug();
lttng_logger_exit();
lttng_abi_exit();
- list_for_each_entry_safe(session_priv, tmpsession_priv, &sessions, list)
+ list_for_each_entry_safe(session_priv, tmpsession_priv, &sessions, node)
lttng_session_destroy(session_priv->pub);
kmem_cache_destroy(event_recorder_cache);
kmem_cache_destroy(event_recorder_private_cache);
+ kmem_cache_destroy(event_counter_cache);
+ kmem_cache_destroy(event_counter_private_cache);
kmem_cache_destroy(event_notifier_cache);
kmem_cache_destroy(event_notifier_private_cache);
lttng_tracepoint_exit();
projects / lttng-modules.git / blobdiff