Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Change-Id: I356d9b91c6e20c288ca931a4d449a54b67f3937c
enum lttng_enabler_format_type format_type;
enum lttng_enabler_format_type format_type;
- struct list_head node; /* per-session list of enablers */
/* head list of struct lttng_ust_filter_bytecode_node */
struct list_head filter_bytecode_head;
struct lttng_kernel_event event_param;
/* head list of struct lttng_ust_filter_bytecode_node */
struct list_head filter_bytecode_head;
struct lttng_kernel_event event_param;
+ unsigned int enabled:1;
+};
+
+struct lttng_event_enabler {
+ struct lttng_enabler base;
+ struct list_head node; /* per-session list of enablers */
struct lttng_channel *chan;
/*
* Unused, but kept around to make it explicit that the tracer can do
* it.
*/
struct lttng_ctx *ctx;
struct lttng_channel *chan;
/*
* Unused, but kept around to make it explicit that the tracer can do
* it.
*/
struct lttng_ctx *ctx;
- unsigned int enabled:1;
+static inline
+struct lttng_enabler *lttng_event_enabler_as_enabler(
+ struct lttng_event_enabler *event_enabler)
+{
+ return &event_enabler->base;
+}
+
+
struct lttng_channel_ops {
struct channel *(*channel_create)(const char *name,
struct lttng_channel *lttng_chan,
struct lttng_channel_ops {
struct channel *(*channel_create)(const char *name,
struct lttng_channel *lttng_chan,
struct lttng_id_tracker vgid_tracker;
unsigned int metadata_dumped:1,
tstate:1; /* Transient enable state */
struct lttng_id_tracker vgid_tracker;
unsigned int metadata_dumped:1,
tstate:1; /* Transient enable state */
+ /* List of event enablers */
struct list_head enablers_head;
/* Hash table of events */
struct lttng_event_ht events_ht;
struct list_head enablers_head;
/* Hash table of events */
struct lttng_event_ht events_ht;
struct list_head *lttng_get_probe_list_head(void);
struct list_head *lttng_get_probe_list_head(void);
-struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_format_type format_type,
+struct lttng_event_enabler *lttng_event_enabler_create(
+ enum lttng_enabler_format_type format_type,
struct lttng_kernel_event *event_param,
struct lttng_channel *chan);
struct lttng_kernel_event *event_param,
struct lttng_channel *chan);
-int lttng_enabler_enable(struct lttng_enabler *enabler);
-int lttng_enabler_disable(struct lttng_enabler *enabler);
+int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler);
+int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler);
int lttng_fix_pending_events(void);
int lttng_session_active(void);
int lttng_fix_pending_events(void);
int lttng_session_active(void);
#endif
void lttng_filter_sync_state(struct lttng_bytecode_runtime *runtime);
#endif
void lttng_filter_sync_state(struct lttng_bytecode_runtime *runtime);
-int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler,
+int lttng_event_enabler_attach_bytecode(struct lttng_event_enabler *event_enabler,
struct lttng_kernel_filter_bytecode __user *bytecode);
struct lttng_kernel_filter_bytecode __user *bytecode);
-void lttng_enabler_event_link_bytecode(struct lttng_event *event,
- struct lttng_enabler *enabler);
+void lttng_event_enabler_link_bytecode(struct lttng_event *event,
+ struct lttng_event_enabler *event_enabler);
int lttng_probes_init(void);
int lttng_probes_init(void);
goto event_error;
if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
|| event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
goto event_error;
if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
|| event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
- struct lttng_enabler *enabler;
+ struct lttng_event_enabler *event_enabler;
if (strutils_is_star_glob_pattern(event_param->name)) {
/*
* If the event name is a star globbing pattern,
* we create the special star globbing enabler.
*/
if (strutils_is_star_glob_pattern(event_param->name)) {
/*
* If the event name is a star globbing pattern,
* we create the special star globbing enabler.
*/
- enabler = lttng_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB,
+ event_enabler = lttng_event_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB,
event_param, channel);
} else {
event_param, channel);
} else {
- enabler = lttng_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
+ event_enabler = lttng_event_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
} else {
struct lttng_event *event;
} else {
struct lttng_event *event;
long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct lttng_event *event;
long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct lttng_event *event;
- struct lttng_enabler *enabler;
+ struct lttng_event_enabler *event_enabler;
enum lttng_event_type *evtype = file->private_data;
switch (cmd) {
enum lttng_event_type *evtype = file->private_data;
switch (cmd) {
event = file->private_data;
return lttng_event_enable(event);
case LTTNG_TYPE_ENABLER:
event = file->private_data;
return lttng_event_enable(event);
case LTTNG_TYPE_ENABLER:
- enabler = file->private_data;
- return lttng_enabler_enable(enabler);
+ event_enabler = file->private_data;
+ return lttng_event_enabler_enable(event_enabler);
default:
WARN_ON_ONCE(1);
return -ENOSYS;
default:
WARN_ON_ONCE(1);
return -ENOSYS;
event = file->private_data;
return lttng_event_disable(event);
case LTTNG_TYPE_ENABLER:
event = file->private_data;
return lttng_event_disable(event);
case LTTNG_TYPE_ENABLER:
- enabler = file->private_data;
- return lttng_enabler_disable(enabler);
+ event_enabler = file->private_data;
+ return lttng_event_enabler_disable(event_enabler);
default:
WARN_ON_ONCE(1);
return -ENOSYS;
default:
WARN_ON_ONCE(1);
return -ENOSYS;
return -EINVAL;
case LTTNG_TYPE_ENABLER:
{
return -EINVAL;
case LTTNG_TYPE_ENABLER:
{
- enabler = file->private_data;
- return lttng_enabler_attach_bytecode(enabler,
+ event_enabler = file->private_data;
+ return lttng_event_enabler_attach_bytecode(event_enabler,
(struct lttng_kernel_filter_bytecode __user *) arg);
}
default:
(struct lttng_kernel_filter_bytecode __user *) arg);
}
default:
int lttng_event_release(struct inode *inode, struct file *file)
{
struct lttng_event *event;
int lttng_event_release(struct inode *inode, struct file *file)
{
struct lttng_event *event;
- struct lttng_enabler *enabler;
+ struct lttng_event_enabler *event_enabler;
enum lttng_event_type *evtype = file->private_data;
if (!evtype)
enum lttng_event_type *evtype = file->private_data;
if (!evtype)
fput(event->chan->file);
break;
case LTTNG_TYPE_ENABLER:
fput(event->chan->file);
break;
case LTTNG_TYPE_ENABLER:
- enabler = file->private_data;
- if (enabler)
- fput(enabler->chan->file);
+ event_enabler = file->private_data;
+ if (event_enabler)
+ fput(event_enabler->chan->file);
break;
default:
WARN_ON_ONCE(1);
break;
default:
WARN_ON_ONCE(1);
static DEFINE_MUTEX(sessions_mutex);
static struct kmem_cache *event_cache;
static DEFINE_MUTEX(sessions_mutex);
static struct kmem_cache *event_cache;
-static void lttng_session_lazy_sync_enablers(struct lttng_session *session);
-static void lttng_session_sync_enablers(struct lttng_session *session);
-static void lttng_enabler_destroy(struct lttng_enabler *enabler);
+static void lttng_session_lazy_sync_event_enablers(struct lttng_session *session);
+static void lttng_session_sync_event_enablers(struct lttng_session *session);
+static void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler);
static void _lttng_event_destroy(struct lttng_event *event);
static void _lttng_channel_destroy(struct lttng_channel *chan);
static void _lttng_event_destroy(struct lttng_event *event);
static void _lttng_channel_destroy(struct lttng_channel *chan);
struct lttng_channel *chan, *tmpchan;
struct lttng_event *event, *tmpevent;
struct lttng_metadata_stream *metadata_stream;
struct lttng_channel *chan, *tmpchan;
struct lttng_event *event, *tmpevent;
struct lttng_metadata_stream *metadata_stream;
- struct lttng_enabler *enabler, *tmpenabler;
+ struct lttng_event_enabler *event_enabler, *tmp_event_enabler;
int ret;
mutex_lock(&sessions_mutex);
int ret;
mutex_lock(&sessions_mutex);
ret = lttng_syscalls_destroy(chan);
WARN_ON(ret);
}
ret = lttng_syscalls_destroy(chan);
WARN_ON(ret);
}
- list_for_each_entry_safe(enabler, tmpenabler,
+ list_for_each_entry_safe(event_enabler, tmp_event_enabler,
&session->enablers_head, node)
&session->enablers_head, node)
- lttng_enabler_destroy(enabler);
+ lttng_event_enabler_destroy(event_enabler);
list_for_each_entry_safe(event, tmpevent, &session->events, list)
_lttng_event_destroy(event);
list_for_each_entry_safe(chan, tmpchan, &session->chan, list) {
list_for_each_entry_safe(event, tmpevent, &session->events, list)
_lttng_event_destroy(event);
list_for_each_entry_safe(chan, tmpchan, &session->chan, list) {
session->tstate = 1;
/* We need to sync enablers with session before activation. */
session->tstate = 1;
/* We need to sync enablers with session before activation. */
- lttng_session_sync_enablers(session);
+ lttng_session_sync_event_enablers(session);
/*
* Snapshot the number of events per channel to know the type of header
/*
* Snapshot the number of events per channel to know the type of header
/* Set transient enabler state to "disabled" */
session->tstate = 0;
/* Set transient enabler state to "disabled" */
session->tstate = 0;
- lttng_session_sync_enablers(session);
+ lttng_session_sync_event_enablers(session);
/* Set each stream's quiescent state. */
list_for_each_entry(chan, &session->chan, list) {
/* Set each stream's quiescent state. */
list_for_each_entry(chan, &session->chan, list) {
}
/* Set transient enabler state to "enabled" */
channel->tstate = 1;
}
/* Set transient enabler state to "enabled" */
channel->tstate = 1;
- lttng_session_sync_enablers(channel->session);
+ lttng_session_sync_event_enablers(channel->session);
/* Set atomically the state to "enabled" */
WRITE_ONCE(channel->enabled, 1);
end:
/* Set atomically the state to "enabled" */
WRITE_ONCE(channel->enabled, 1);
end:
WRITE_ONCE(channel->enabled, 0);
/* Set transient enabler state to "enabled" */
channel->tstate = 0;
WRITE_ONCE(channel->enabled, 0);
/* Set transient enabler state to "enabled" */
channel->tstate = 0;
- lttng_session_sync_enablers(channel->session);
+ lttng_session_sync_event_enablers(channel->session);
end:
mutex_unlock(&sessions_mutex);
return ret;
end:
mutex_unlock(&sessions_mutex);
return ret;
-int lttng_event_match_enabler(struct lttng_event *event,
- struct lttng_enabler *enabler)
+int lttng_event_enabler_match_event(struct lttng_event_enabler *event_enabler,
+ struct lttng_event *event)
- if (enabler->event_param.instrumentation != event->instrumentation)
+ struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler(
+ event_enabler);
+
+ if (base_enabler->event_param.instrumentation != event->instrumentation)
- if (lttng_desc_match_enabler(event->desc, enabler)
- && event->chan == enabler->chan)
+ if (lttng_desc_match_enabler(event->desc, base_enabler)
+ && event->chan == event_enabler->chan)
return 1;
else
return 0;
}
static
return 1;
else
return 0;
}
static
-struct lttng_enabler_ref *lttng_event_enabler_ref(struct lttng_event *event,
+struct lttng_enabler_ref *lttng_enabler_ref(
+ struct list_head *enablers_ref_list,
struct lttng_enabler *enabler)
{
struct lttng_enabler_ref *enabler_ref;
struct lttng_enabler *enabler)
{
struct lttng_enabler_ref *enabler_ref;
- list_for_each_entry(enabler_ref,
- &event->enablers_ref_head, node) {
+ list_for_each_entry(enabler_ref, enablers_ref_list, node) {
if (enabler_ref->ref == enabler)
return enabler_ref;
}
if (enabler_ref->ref == enabler)
return enabler_ref;
}
-void lttng_create_tracepoint_if_missing(struct lttng_enabler *enabler)
+void lttng_create_tracepoint_if_missing(struct lttng_event_enabler *event_enabler)
- struct lttng_session *session = enabler->chan->session;
+ struct lttng_session *session = event_enabler->chan->session;
struct lttng_probe_desc *probe_desc;
const struct lttng_event_desc *desc;
int i;
struct lttng_probe_desc *probe_desc;
const struct lttng_event_desc *desc;
int i;
struct lttng_event *event;
desc = probe_desc->event_desc[i];
struct lttng_event *event;
desc = probe_desc->event_desc[i];
- if (!lttng_desc_match_enabler(desc, enabler))
+ if (!lttng_desc_match_enabler(desc,
+ lttng_event_enabler_as_enabler(event_enabler)))
continue;
event_name = desc->name;
name_len = strlen(event_name);
continue;
event_name = desc->name;
name_len = strlen(event_name);
head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
lttng_hlist_for_each_entry(event, head, hlist) {
if (event->desc == desc
head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
lttng_hlist_for_each_entry(event, head, hlist) {
if (event->desc == desc
- && event->chan == enabler->chan)
+ && event->chan == event_enabler->chan)
* We need to create an event for this
* event probe.
*/
* We need to create an event for this
* event probe.
*/
- event = _lttng_event_create(enabler->chan,
+ event = _lttng_event_create(event_enabler->chan,
NULL, NULL, desc,
LTTNG_KERNEL_TRACEPOINT);
if (!event) {
NULL, NULL, desc,
LTTNG_KERNEL_TRACEPOINT);
if (!event) {
-void lttng_create_syscall_if_missing(struct lttng_enabler *enabler)
+void lttng_create_syscall_if_missing(struct lttng_event_enabler *event_enabler)
- ret = lttng_syscalls_register(enabler->chan, NULL);
+ ret = lttng_syscalls_register(event_enabler->chan, NULL);
* Should be called with sessions mutex held.
*/
static
* Should be called with sessions mutex held.
*/
static
-void lttng_create_event_if_missing(struct lttng_enabler *enabler)
+void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler)
- switch (enabler->event_param.instrumentation) {
+ switch (event_enabler->base.event_param.instrumentation) {
case LTTNG_KERNEL_TRACEPOINT:
case LTTNG_KERNEL_TRACEPOINT:
- lttng_create_tracepoint_if_missing(enabler);
+ lttng_create_tracepoint_if_missing(event_enabler);
break;
case LTTNG_KERNEL_SYSCALL:
break;
case LTTNG_KERNEL_SYSCALL:
- lttng_create_syscall_if_missing(enabler);
+ lttng_create_syscall_if_missing(event_enabler);
break;
default:
WARN_ON_ONCE(1);
break;
default:
WARN_ON_ONCE(1);
- * Create events associated with an enabler (if not already present),
+ * Create events associated with an event_enabler (if not already present),
* and add backward reference from the event to the enabler.
* Should be called with sessions mutex held.
*/
static
* and add backward reference from the event to the enabler.
* Should be called with sessions mutex held.
*/
static
-int lttng_enabler_ref_events(struct lttng_enabler *enabler)
+int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
- struct lttng_channel *chan = enabler->chan;
- struct lttng_session *session = chan->session;
+ struct lttng_channel *chan = event_enabler->chan;
+ struct lttng_session *session = event_enabler->chan->session;
+ struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler(event_enabler);
struct lttng_event *event;
struct lttng_event *event;
- if (enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL &&
- enabler->event_param.u.syscall.entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT &&
- enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL &&
- enabler->event_param.u.syscall.match == LTTNG_SYSCALL_MATCH_NAME &&
- !strcmp(enabler->event_param.name, "*")) {
- if (enabler->enabled)
+ if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL &&
+ base_enabler->event_param.u.syscall.entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT &&
+ base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL &&
+ base_enabler->event_param.u.syscall.match == LTTNG_SYSCALL_MATCH_NAME &&
+ !strcmp(base_enabler->event_param.name, "*")) {
+ if (base_enabler->enabled)
WRITE_ONCE(chan->syscall_all, 1);
else
WRITE_ONCE(chan->syscall_all, 0);
}
/* First ensure that probe events are created for this enabler. */
WRITE_ONCE(chan->syscall_all, 1);
else
WRITE_ONCE(chan->syscall_all, 0);
}
/* First ensure that probe events are created for this enabler. */
- lttng_create_event_if_missing(enabler);
+ lttng_create_event_if_missing(event_enabler);
- /* For each event matching enabler in session event list. */
+ /* For each event matching event_enabler in session event list. */
list_for_each_entry(event, &session->events, list) {
struct lttng_enabler_ref *enabler_ref;
list_for_each_entry(event, &session->events, list) {
struct lttng_enabler_ref *enabler_ref;
- if (!lttng_event_match_enabler(event, enabler))
+ if (!lttng_event_enabler_match_event(event_enabler, event))
- enabler_ref = lttng_event_enabler_ref(event, enabler);
+ enabler_ref = lttng_enabler_ref(&event->enablers_ref_head,
+ lttng_event_enabler_as_enabler(event_enabler));
if (!enabler_ref) {
/*
* If no backward ref, create it.
if (!enabler_ref) {
/*
* If no backward ref, create it.
- * Add backward ref from event to enabler.
+ * Add backward ref from event to event_enabler.
*/
enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
if (!enabler_ref)
return -ENOMEM;
*/
enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
if (!enabler_ref)
return -ENOMEM;
- enabler_ref->ref = enabler;
+ enabler_ref->ref = lttng_event_enabler_as_enabler(event_enabler);
list_add(&enabler_ref->node,
&event->enablers_ref_head);
}
list_add(&enabler_ref->node,
&event->enablers_ref_head);
}
/*
* Link filter bytecodes if not linked yet.
*/
/*
* Link filter bytecodes if not linked yet.
*/
- lttng_enabler_event_link_bytecode(event, enabler);
+ lttng_event_enabler_link_bytecode(event, event_enabler);
/* TODO: merge event context. */
}
/* TODO: merge event context. */
}
struct lttng_session *session;
list_for_each_entry(session, &sessions, list)
struct lttng_session *session;
list_for_each_entry(session, &sessions, list)
- lttng_session_lazy_sync_enablers(session);
+ lttng_session_lazy_sync_event_enablers(session);
-struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_format_type format_type,
+struct lttng_event_enabler *lttng_event_enabler_create(
+ enum lttng_enabler_format_type format_type,
struct lttng_kernel_event *event_param,
struct lttng_channel *chan)
{
struct lttng_kernel_event *event_param,
struct lttng_channel *chan)
{
- struct lttng_enabler *enabler;
+ struct lttng_event_enabler *event_enabler;
- enabler = kzalloc(sizeof(*enabler), GFP_KERNEL);
- if (!enabler)
+ event_enabler = kzalloc(sizeof(*event_enabler), GFP_KERNEL);
+ if (!event_enabler)
- enabler->format_type = format_type;
- INIT_LIST_HEAD(&enabler->filter_bytecode_head);
- memcpy(&enabler->event_param, event_param,
- sizeof(enabler->event_param));
- enabler->chan = chan;
+ event_enabler->base.format_type = format_type;
+ INIT_LIST_HEAD(&event_enabler->base.filter_bytecode_head);
+ memcpy(&event_enabler->base.event_param, event_param,
+ sizeof(event_enabler->base.event_param));
+ event_enabler->chan = chan;
- enabler->enabled = 0;
- enabler->evtype = LTTNG_TYPE_ENABLER;
+ event_enabler->base.enabled = 0;
+ event_enabler->base.evtype = LTTNG_TYPE_ENABLER;
mutex_lock(&sessions_mutex);
mutex_lock(&sessions_mutex);
- list_add(&enabler->node, &enabler->chan->session->enablers_head);
- lttng_session_lazy_sync_enablers(enabler->chan->session);
+ list_add(&event_enabler->node, &event_enabler->chan->session->enablers_head);
+ lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
mutex_unlock(&sessions_mutex);
mutex_unlock(&sessions_mutex);
-int lttng_enabler_enable(struct lttng_enabler *enabler)
+int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler)
{
mutex_lock(&sessions_mutex);
{
mutex_lock(&sessions_mutex);
- enabler->enabled = 1;
- lttng_session_lazy_sync_enablers(enabler->chan->session);
+ lttng_event_enabler_as_enabler(event_enabler)->enabled = 1;
+ lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
mutex_unlock(&sessions_mutex);
return 0;
}
mutex_unlock(&sessions_mutex);
return 0;
}
-int lttng_enabler_disable(struct lttng_enabler *enabler)
+int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler)
{
mutex_lock(&sessions_mutex);
{
mutex_lock(&sessions_mutex);
- enabler->enabled = 0;
- lttng_session_lazy_sync_enablers(enabler->chan->session);
+ lttng_event_enabler_as_enabler(event_enabler)->enabled = 0;
+ lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
mutex_unlock(&sessions_mutex);
return 0;
}
mutex_unlock(&sessions_mutex);
return 0;
}
int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler,
struct lttng_kernel_filter_bytecode __user *bytecode)
{
int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler,
struct lttng_kernel_filter_bytecode __user *bytecode)
{
sizeof(*bytecode) + bytecode_len);
if (ret)
goto error_free;
sizeof(*bytecode) + bytecode_len);
if (ret)
goto error_free;
bytecode_node->enabler = enabler;
/* Enforce length based on allocated size */
bytecode_node->bc.len = bytecode_len;
list_add_tail(&bytecode_node->node, &enabler->filter_bytecode_head);
bytecode_node->enabler = enabler;
/* Enforce length based on allocated size */
bytecode_node->bc.len = bytecode_len;
list_add_tail(&bytecode_node->node, &enabler->filter_bytecode_head);
- lttng_session_lazy_sync_enablers(enabler->chan->session);
+int lttng_event_enabler_attach_bytecode(struct lttng_event_enabler *event_enabler,
+ struct lttng_kernel_filter_bytecode __user *bytecode)
+{
+ int ret;
+ ret = lttng_enabler_attach_bytecode(
+ lttng_event_enabler_as_enabler(event_enabler), bytecode);
+ if (ret)
+ goto error;
+
+ lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
+ return 0;
+
+error:
+ return ret;
+}
+
int lttng_event_add_callsite(struct lttng_event *event,
struct lttng_kernel_event_callsite __user *callsite)
{
int lttng_event_add_callsite(struct lttng_event *event,
struct lttng_kernel_event_callsite __user *callsite)
{
-int lttng_enabler_attach_context(struct lttng_enabler *enabler,
+int lttng_event_enabler_attach_context(struct lttng_event_enabler *event_enabler,
struct lttng_kernel_context *context_param)
{
return -ENOSYS;
struct lttng_kernel_context *context_param)
{
return -ENOSYS;
&enabler->filter_bytecode_head, node) {
kfree(filter_node);
}
&enabler->filter_bytecode_head, node) {
kfree(filter_node);
}
+}
+
+static
+void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler)
+{
+ lttng_enabler_destroy(lttng_event_enabler_as_enabler(event_enabler));
- lttng_destroy_context(enabler->ctx);
+ lttng_destroy_context(event_enabler->ctx);
- list_del(&enabler->node);
- kfree(enabler);
+ list_del(&event_enabler->node);
+ kfree(event_enabler);
- * lttng_session_sync_enablers should be called just before starting a
+ * lttng_session_sync_event_enablers should be called just before starting a
* session.
* Should be called with sessions mutex held.
*/
static
* session.
* Should be called with sessions mutex held.
*/
static
-void lttng_session_sync_enablers(struct lttng_session *session)
+void lttng_session_sync_event_enablers(struct lttng_session *session)
- struct lttng_enabler *enabler;
+ struct lttng_event_enabler *event_enabler;
struct lttng_event *event;
struct lttng_event *event;
- list_for_each_entry(enabler, &session->enablers_head, node)
- lttng_enabler_ref_events(enabler);
+ list_for_each_entry(event_enabler, &session->enablers_head, 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
/*
* For each event, if at least one of its enablers is enabled,
* and its channel and session transient states are enabled, we
* Should be called with sessions mutex held.
*/
static
* Should be called with sessions mutex held.
*/
static
-void lttng_session_lazy_sync_enablers(struct lttng_session *session)
+void lttng_session_lazy_sync_event_enablers(struct lttng_session *session)
{
/* We can skip if session is not active */
if (!session->active)
return;
{
/* We can skip if session is not active */
if (!session->active)
return;
- lttng_session_sync_enablers(session);
+ lttng_session_sync_event_enablers(session);
/*
* Link bytecode for all enablers referenced by an event.
*/
/*
* Link bytecode for all enablers referenced by an event.
*/
-void lttng_enabler_event_link_bytecode(struct lttng_event *event,
- struct lttng_enabler *enabler)
+void lttng_event_enabler_link_bytecode(struct lttng_event *event,
+ struct lttng_event_enabler *event_enabler)
{
struct lttng_filter_bytecode_node *bc;
struct lttng_bytecode_runtime *runtime;
{
struct lttng_filter_bytecode_node *bc;
struct lttng_bytecode_runtime *runtime;
+ struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler(event_enabler);
/* Can only be called for events with desc attached */
WARN_ON_ONCE(!event->desc);
/* Link each bytecode. */
/* Can only be called for events with desc attached */
WARN_ON_ONCE(!event->desc);
/* Link each bytecode. */
- list_for_each_entry(bc, &enabler->filter_bytecode_head, node) {
+ list_for_each_entry(bc, &base_enabler->filter_bytecode_head, node) {
int found = 0, ret;
struct list_head *insert_loc;
int found = 0, ret;
struct list_head *insert_loc;