X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=src%2Flttng-events.c;h=5023d450b1bd77f50969776c32b8e2735a192317;hp=7e308741d46e7bd96c015153b9c402e72ed2e93b;hb=HEAD;hpb=756a020cce15ab4ae515051c469437713ad6515d diff --git a/src/lttng-events.c b/src/lttng-events.c index 7e308741..73f591fd 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -23,7 +23,6 @@ #include #include #include -#include #include #include #include @@ -47,7 +46,13 @@ #include #include #include -#include + +#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,16,0) \ + || LTTNG_RHEL_KERNEL_RANGE(5,14,0,162,0,0, 5,15,0,0,0,0)) +#include +#else +#include +#endif #define METADATA_CACHE_DEFAULT_SIZE 4096 @@ -71,11 +76,9 @@ static void lttng_event_enabler_sync(struct lttng_event_enabler_common *event_en static void _lttng_event_destroy(struct lttng_kernel_event_common *event); static void _lttng_channel_destroy(struct lttng_kernel_channel_buffer *chan); -static int _lttng_event_unregister(struct lttng_kernel_event_common *event); +static void _lttng_event_unregister(struct lttng_kernel_event_common *event); static -int _lttng_event_metadata_statedump(struct lttng_kernel_session *session, - struct lttng_kernel_channel_buffer *chan, - struct lttng_kernel_event_recorder *event); +int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event); static int _lttng_session_metadata_statedump(struct lttng_kernel_session *session); static @@ -99,15 +102,9 @@ void synchronize_trace(void) synchronize_sched(); #endif -#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) #ifdef CONFIG_PREEMPT_RT_FULL synchronize_rcu(); #endif -#else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */ -#ifdef CONFIG_PREEMPT_RT - synchronize_rcu(); -#endif -#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */ } void lttng_lock_sessions(void) @@ -362,10 +359,8 @@ void lttng_session_destroy(struct lttng_kernel_session *session) ret = lttng_syscalls_unregister_syscall_table(&chan_priv->parent.syscall_table); WARN_ON(ret); } - list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { - ret = _lttng_event_unregister(&event_recorder_priv->pub->parent); - WARN_ON(ret); - } + list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) + _lttng_event_unregister(&event_recorder_priv->pub->parent); synchronize_trace(); /* Wait for in-flight events to complete */ list_for_each_entry(chan_priv, &session->priv->chan, node) { ret = lttng_syscalls_destroy_syscall_table(&chan_priv->parent.syscall_table); @@ -412,10 +407,8 @@ void lttng_event_notifier_group_destroy( WARN_ON(ret); list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv, - &event_notifier_group->event_notifiers_head, parent.node) { - ret = _lttng_event_unregister(&event_notifier_priv->pub->parent); - WARN_ON(ret); - } + &event_notifier_group->event_notifiers_head, parent.node) + _lttng_event_unregister(&event_notifier_priv->pub->parent); /* Wait for in-flight event notifier to complete */ synchronize_trace(); @@ -866,6 +859,48 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream) wake_up_interruptible(&stream->read_wait); } +static +bool lttng_kernel_event_id_available(struct lttng_event_enabler_common *event_enabler) +{ + struct lttng_kernel_abi_event *event_param = &event_enabler->event_param; + enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; + + switch (event_enabler->enabler_type) { + case LTTNG_EVENT_ENABLER_TYPE_RECORDER: + { + struct lttng_event_recorder_enabler *event_recorder_enabler = + container_of(event_enabler, struct lttng_event_recorder_enabler, parent); + struct lttng_kernel_channel_buffer *chan = event_recorder_enabler->chan; + + switch (itype) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + if (chan->priv->free_event_id == -1U) + return false; + return true; + case LTTNG_KERNEL_ABI_KRETPROBE: + /* kretprobes require 2 event IDs. */ + if (chan->priv->free_event_id >= -2U) + return false; + return true; + default: + WARN_ON_ONCE(1); + return false; + } + } + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + return true; + default: + WARN_ON_ONCE(1); + return false; + } +} + static struct lttng_kernel_event_common *lttng_kernel_event_alloc(struct lttng_event_enabler_common *event_enabler) { @@ -970,27 +1005,71 @@ void lttng_kernel_event_free(struct lttng_kernel_event_common *event) } } +static +int lttng_kernel_event_notifier_clear_error_counter(struct lttng_kernel_event_common *event) +{ + switch (event->type) { + case LTTNG_KERNEL_EVENT_TYPE_RECORDER: + return 0; + case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER: + { + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + struct lttng_counter *error_counter; + struct lttng_event_notifier_group *event_notifier_group = event_notifier->priv->group; + size_t dimension_index[1]; + int ret; + + /* + * Clear the error counter bucket. The sessiond keeps track of which + * bucket is currently in use. We trust it. The session lock + * synchronizes against concurrent creation of the error + * counter. + */ + error_counter = event_notifier_group->error_counter; + if (!error_counter) + return 0; + /* + * Check that the index is within the boundary of the counter. + */ + if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) { + printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n", + event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index); + return -EINVAL; + } + + dimension_index[0] = event_notifier->priv->error_counter_index; + ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index); + if (ret) { + printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n", + event_notifier->priv->error_counter_index); + return -EINVAL; + } + return 0; + } + default: + return -EINVAL; + } +} + /* * Supports event creation while tracing session is active. * Needs to be called with sessions mutex held. */ -static -struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_event_recorder_enabler *event_enabler, +struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, const struct lttng_kernel_event_desc *event_desc) { - struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); - struct lttng_kernel_channel_buffer *chan = event_enabler->chan; - struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler); + struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler); + struct lttng_kernel_abi_event *event_param = &event_enabler->event_param; enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; struct lttng_kernel_event_common_private *event_priv; struct lttng_kernel_event_common *event; - struct lttng_kernel_event_recorder_private *event_recorder_priv; - struct lttng_kernel_event_recorder *event_recorder; const char *event_name; struct hlist_head *head; int ret; - if (chan->priv->free_event_id == -1U) { + if (!lttng_kernel_event_id_available(event_enabler)) { ret = -EMFILE; goto full; } @@ -1022,31 +1101,25 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, event_name); lttng_hlist_for_each_entry(event_priv, head, hlist_node) { - event_recorder_priv = container_of(event_priv, struct lttng_kernel_event_recorder_private, parent); - - WARN_ON_ONCE(!event_priv->desc); - if (!strncmp(event_priv->desc->event_name, event_name, - LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) - && chan == event_recorder_priv->pub->chan) { + if (lttng_event_enabler_event_name_match_event(event_enabler, event_name, event_priv->pub)) { ret = -EEXIST; goto exist; } } - event = lttng_kernel_event_alloc(&event_enabler->parent); + event = lttng_kernel_event_alloc(event_enabler); if (!event) { ret = -ENOMEM; goto alloc_error; } - event_recorder = container_of(event, struct lttng_kernel_event_recorder, parent); switch (itype) { case LTTNG_KERNEL_ABI_TRACEPOINT: /* Event will be enabled by enabler sync. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 0; - event_recorder->priv->parent.desc = lttng_event_desc_get(event_name); - if (!event_recorder->priv->parent.desc) { + event->enabled = 0; + event->priv->registered = 0; + event->priv->desc = lttng_event_desc_get(event_name); + if (!event->priv->desc) { ret = -ENOENT; goto register_error; } @@ -1059,8 +1132,8 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 1; + event->enabled = 0; + event->priv->registered = 1; /* * Populate lttng_event structure before event * registration. @@ -1070,19 +1143,18 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l event_param->u.kprobe.symbol_name, event_param->u.kprobe.offset, event_param->u.kprobe.addr, - &event_recorder->parent); + event); if (ret) { ret = -EINVAL; goto register_error; } - ret = try_module_get(event_recorder->priv->parent.desc->owner); + ret = try_module_get(event->priv->desc->owner); WARN_ON_ONCE(!ret); break; case LTTNG_KERNEL_ABI_KRETPROBE: { struct lttng_kernel_event_common *event_return; - struct lttng_kernel_event_recorder *event_recorder_return; /* kretprobe defines 2 events */ /* @@ -1092,12 +1164,11 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l event->enabled = 0; event->priv->registered = 1; - event_return = lttng_kernel_event_alloc(&event_enabler->parent); + event_return = lttng_kernel_event_alloc(event_enabler); if (!event) { ret = -ENOMEM; goto alloc_error; } - event_recorder_return = container_of(event_return, struct lttng_kernel_event_recorder, parent); event_return->enabled = 0; event_return->priv->registered = 1; @@ -1121,15 +1192,15 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l WARN_ON_ONCE(!ret); ret = try_module_get(event_return->priv->desc->owner); WARN_ON_ONCE(!ret); - ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder_return); + ret = _lttng_event_recorder_metadata_statedump(event_return); WARN_ON_ONCE(ret > 0); if (ret) { lttng_kernel_event_free(event_return); - module_put(event_recorder_return->priv->parent.desc->owner); - module_put(event_recorder->priv->parent.desc->owner); + module_put(event_return->priv->desc->owner); + module_put(event->priv->desc->owner); goto statedump_error; } - list_add(&event_return->priv->node, &chan->parent.session->priv->events); + list_add(&event_return->priv->node, event_list_head); break; } @@ -1138,18 +1209,18 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 0; - event_recorder->priv->parent.desc = event_desc; + event->enabled = 0; + event->priv->registered = 0; + event->priv->desc = event_desc; switch (event_param->u.syscall.entryexit) { case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: ret = -EINVAL; goto register_error; case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: - event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; + event->priv->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; break; case LTTNG_KERNEL_ABI_SYSCALL_EXIT: - event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT; + event->priv->u.syscall.entryexit = LTTNG_SYSCALL_EXIT; break; } switch (event_param->u.syscall.abi) { @@ -1157,13 +1228,13 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l ret = -EINVAL; goto register_error; case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE: - event_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; + event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; break; case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT: - event_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; + event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; break; } - if (!event_recorder->priv->parent.desc) { + if (!event->priv->desc) { ret = -EINVAL; goto register_error; } @@ -1174,8 +1245,8 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l * Needs to be explicitly enabled after creation, since * we may want to apply filters. */ - event_recorder->parent.enabled = 0; - event_recorder->priv->parent.registered = 1; + event->enabled = 0; + event->priv->registered = 1; /* * Populate lttng_event structure before event @@ -1185,290 +1256,45 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l ret = lttng_uprobes_register_event(event_param->name, event_param->u.uprobe.fd, - &event_recorder->parent); + event); if (ret) goto register_error; - ret = try_module_get(event_recorder->priv->parent.desc->owner); + ret = try_module_get(event->priv->desc->owner); WARN_ON_ONCE(!ret); break; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; default: WARN_ON_ONCE(1); ret = -EINVAL; goto register_error; } - ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder); + + ret = _lttng_event_recorder_metadata_statedump(event); WARN_ON_ONCE(ret > 0); if (ret) { goto statedump_error; } - hlist_add_head(&event_recorder->priv->parent.hlist_node, head); - list_add(&event_recorder->priv->parent.node, &chan->parent.session->priv->events); - return event_recorder; - -statedump_error: - /* If a statedump error occurs, events will not be readable. */ -register_error: - lttng_kernel_event_free(event); -alloc_error: -exist: -type_error: -full: - return ERR_PTR(ret); -} - -static -struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler, - const struct lttng_kernel_event_desc *event_desc) -{ - struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); - struct lttng_event_notifier_group *event_notifier_group = event_enabler->group; - struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; - uint64_t token = event_enabler->parent.user_token; - enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; - struct lttng_kernel_event_common_private *event_priv; - struct lttng_kernel_event_common *event; - struct lttng_kernel_event_notifier_private *event_notifier_priv; - struct lttng_kernel_event_notifier *event_notifier; - struct lttng_counter *error_counter; - const char *event_name; - struct hlist_head *head; - int ret; - - switch (itype) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - event_name = event_desc->event_name; - break; - - case LTTNG_KERNEL_ABI_KPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_UPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_SYSCALL: - event_name = event_param->name; - break; - - case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; - default: - WARN_ON_ONCE(1); - ret = -EINVAL; - goto 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) { - event_notifier_priv = container_of(event_priv, struct lttng_kernel_event_notifier_private, parent); - - WARN_ON_ONCE(!event_priv->desc); - if (!strncmp(event_priv->desc->event_name, event_name, - LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) - && event_notifier_group == event_notifier_priv->group - && token == event_priv->user_token) { - ret = -EEXIST; - goto exist; - } - } - - event = lttng_kernel_event_alloc(&event_enabler->parent); - if (!event) { - ret = -ENOMEM; - goto alloc_error; - } - event_notifier = container_of(event, struct lttng_kernel_event_notifier, parent); - - switch (itype) { - case LTTNG_KERNEL_ABI_TRACEPOINT: - /* Event will be enabled by enabler sync. */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 0; - event_notifier->priv->parent.desc = lttng_event_desc_get(event_name); - if (!event_notifier->priv->parent.desc) { - ret = -ENOENT; - goto register_error; - } - /* Populate lttng_event_notifier structure before event registration. */ - smp_wmb(); - break; - - case LTTNG_KERNEL_ABI_KPROBE: - /* - * Needs to be explicitly enabled after creation, since - * we may want to apply filters. - */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 1; - /* - * Populate lttng_event_notifier structure before event - * registration. - */ - smp_wmb(); - ret = lttng_kprobes_register_event(event_param->u.kprobe.symbol_name, - event_param->u.kprobe.symbol_name, - event_param->u.kprobe.offset, - event_param->u.kprobe.addr, - &event_notifier->parent); - if (ret) { - ret = -EINVAL; - goto register_error; - } - ret = try_module_get(event_notifier->priv->parent.desc->owner); - WARN_ON_ONCE(!ret); - break; - - case LTTNG_KERNEL_ABI_SYSCALL: - /* - * Needs to be explicitly enabled after creation, since - * we may want to apply filters. - */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 0; - event_notifier->priv->parent.desc = event_desc; - switch (event_param->u.syscall.entryexit) { - case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: - ret = -EINVAL; - goto register_error; - case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: - event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; - break; - case LTTNG_KERNEL_ABI_SYSCALL_EXIT: - event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT; - break; - } - switch (event_param->u.syscall.abi) { - case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL: - ret = -EINVAL; - goto register_error; - case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE: - event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; - break; - case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT: - event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; - break; - } - - if (!event_notifier->priv->parent.desc) { - ret = -EINVAL; - goto register_error; - } - break; - - case LTTNG_KERNEL_ABI_UPROBE: - /* - * Needs to be explicitly enabled after creation, since - * we may want to apply filters. - */ - event_notifier->parent.enabled = 0; - event_notifier->priv->parent.registered = 1; - - /* - * Populate lttng_event_notifier structure before - * event_notifier registration. - */ - smp_wmb(); - - ret = lttng_uprobes_register_event(event_param->name, - event_param->u.uprobe.fd, - &event_notifier->parent); - if (ret) - goto register_error; - ret = try_module_get(event_notifier->priv->parent.desc->owner); - WARN_ON_ONCE(!ret); - break; - - case LTTNG_KERNEL_ABI_KRETPROBE: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_FUNCTION: - lttng_fallthrough; - case LTTNG_KERNEL_ABI_NOOP: - lttng_fallthrough; - default: - WARN_ON_ONCE(1); - ret = -EINVAL; + ret = lttng_kernel_event_notifier_clear_error_counter(event); + if (ret) goto register_error; - } - list_add(&event_notifier->priv->parent.node, &event_notifier_group->event_notifiers_head); - hlist_add_head(&event_notifier->priv->parent.hlist_node, head); + hlist_add_head(&event->priv->hlist_node, head); + list_add(&event->priv->node, event_list_head); - /* - * Clear the error counter bucket. The sessiond keeps track of which - * bucket is currently in use. We trust it. The session lock - * synchronizes against concurrent creation of the error - * counter. - */ - error_counter = event_notifier_group->error_counter; - if (error_counter) { - size_t dimension_index[1]; - - /* - * Check that the index is within the boundary of the counter. - */ - if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) { - printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n", - event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index); - ret = -EINVAL; - goto register_error; - } - - dimension_index[0] = event_notifier->priv->error_counter_index; - ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index); - if (ret) { - printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n", - event_notifier->priv->error_counter_index); - goto register_error; - } - } - - return event_notifier; + return event; +statedump_error: + /* If a statedump error occurs, events will not be readable. */ register_error: lttng_kernel_event_free(event); alloc_error: exist: type_error: +full: return ERR_PTR(ret); } -struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, - const struct lttng_kernel_event_desc *event_desc) -{ - 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; - - event_recorder = _lttng_kernel_event_recorder_create(event_recorder_enabler, event_desc); - if (!event_recorder) - return NULL; - return &event_recorder->parent; - } - case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: - { - struct lttng_event_notifier_enabler *event_notifier_enabler = - container_of(event_enabler, struct lttng_event_notifier_enabler, parent); - struct lttng_kernel_event_notifier *event_notifier; - - event_notifier = _lttng_kernel_event_notifier_create(event_notifier_enabler, event_desc); - if (!event_notifier) - return NULL; - return &event_notifier->parent; - } - default: - return NULL; - } -} - struct lttng_kernel_event_common *lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, const struct lttng_kernel_event_desc *event_desc) { @@ -1480,8 +1306,6 @@ struct lttng_kernel_event_common *lttng_kernel_event_create(struct lttng_event_e return event; } - - int lttng_kernel_counter_read(struct lttng_counter *counter, const size_t *dim_indexes, int32_t cpu, int64_t *val, bool *overflow, bool *underflow) @@ -1504,20 +1328,19 @@ int lttng_kernel_counter_clear(struct lttng_counter *counter, return counter->ops->counter_clear(counter->counter, dim_indexes); } -/* Only used for tracepoints for now. */ +/* Only used for tracepoints and system calls for now. */ static void register_event(struct lttng_kernel_event_common *event) { const struct lttng_kernel_event_desc *desc; int ret = -EINVAL; - if (event->priv->registered) - return; + WARN_ON_ONCE(event->priv->registered); desc = event->priv->desc; switch (event->priv->instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname, + ret = lttng_tracepoint_probe_register(desc->event_kname, desc->tp_class->probe_callback, event); break; @@ -1550,23 +1373,24 @@ void register_event(struct lttng_kernel_event_common *event) default: WARN_ON_ONCE(1); } + WARN_ON_ONCE(ret); if (!ret) event->priv->registered = 1; } -int _lttng_event_unregister(struct lttng_kernel_event_common *event) +static +void unregister_event(struct lttng_kernel_event_common *event) { struct lttng_kernel_event_common_private *event_priv = event->priv; const struct lttng_kernel_event_desc *desc; int ret = -EINVAL; - if (!event_priv->registered) - return 0; + WARN_ON_ONCE(!event->priv->registered); desc = event_priv->desc; switch (event_priv->instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - ret = lttng_wrapper_tracepoint_probe_unregister(event_priv->desc->event_kname, + ret = lttng_tracepoint_probe_unregister(event_priv->desc->event_kname, event_priv->desc->tp_class->probe_callback, event); break; @@ -1613,9 +1437,16 @@ int _lttng_event_unregister(struct lttng_kernel_event_common *event) default: WARN_ON_ONCE(1); } + WARN_ON_ONCE(ret); if (!ret) event_priv->registered = 0; - return ret; +} + +static +void _lttng_event_unregister(struct lttng_kernel_event_common *event) +{ + if (event->priv->registered) + unregister_event(event); } /* @@ -1716,6 +1547,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) } } +static struct lttng_kernel_id_tracker *get_tracker(struct lttng_kernel_session *session, enum tracker_type tracker_type) { @@ -1931,7 +1763,7 @@ int lttng_session_list_tracker_ids(struct lttng_kernel_session *session, struct seq_file *m; int file_fd, ret; - file_fd = lttng_get_unused_fd(); + file_fd = get_unused_fd_flags(0); if (file_fd < 0) { ret = file_fd; goto fd_error; @@ -2174,6 +2006,47 @@ bool lttng_event_enabler_desc_match_event(struct lttng_event_enabler_common *eve } } +bool lttng_event_enabler_event_name_match_event(struct lttng_event_enabler_common *event_enabler, + const char *event_name, + struct lttng_kernel_event_common *event) +{ + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; + + switch (event_enabler->enabler_type) { + case LTTNG_EVENT_ENABLER_TYPE_RECORDER: + { + struct lttng_event_recorder_enabler *event_recorder_enabler = + container_of(event_enabler, struct lttng_event_recorder_enabler, parent); + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) + && event_recorder->chan == event_recorder_enabler->chan) + return true; + else + return false; + } + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + { + struct lttng_event_notifier_enabler *event_notifier_enabler = + container_of(event_enabler, struct lttng_event_notifier_enabler, parent); + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + + if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1) + && event_notifier->priv->group == event_notifier_enabler->group + && event->priv->user_token == event_enabler->user_token) + return true; + else + return false; + } + default: + WARN_ON_ONCE(1); + return false; + } +} + static struct lttng_enabler_ref *lttng_enabler_ref( struct list_head *enablers_ref_list, @@ -2189,7 +2062,7 @@ struct lttng_enabler_ref *lttng_enabler_ref( } static -void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common *event_enabler) +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; @@ -2205,7 +2078,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common */ list_for_each_entry(probe_desc, probe_list, head) { for (i = 0; i < probe_desc->nr_events; i++) { - int found = 0; + bool found = false; struct hlist_head *head; struct lttng_kernel_event_common *event; struct lttng_kernel_event_common_private *event_priv; @@ -2219,8 +2092,10 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common */ 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 = 1; + if (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub)) { + found = true; + break; + } } if (found) continue; @@ -2229,7 +2104,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common * We need to create an event for this event probe. */ event = _lttng_kernel_event_create(event_enabler, desc); - if (!event) { + if (IS_ERR(event)) { printk(KERN_INFO "LTTng: Unable to create event %s\n", probe_desc->event_desc[i]->event_name); } @@ -2237,29 +2112,23 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common } } -static -void lttng_create_syscall_event_if_missing(struct lttng_event_enabler_common *event_enabler) -{ - int ret; - - ret = lttng_syscalls_register_event(event_enabler); - WARN_ON_ONCE(ret); -} - /* * Create event if it is missing and present in the list of tracepoint probes. * Should be called with sessions mutex held. */ static -void lttng_create_event_if_missing(struct lttng_event_enabler_common *event_enabler) +void lttng_event_enabler_create_events_if_missing(struct lttng_event_enabler_common *event_enabler) { + int ret; + switch (event_enabler->event_param.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_create_tracepoint_event_if_missing(event_enabler); + lttng_event_enabler_create_tracepoint_events_if_missing(event_enabler); break; case LTTNG_KERNEL_ABI_SYSCALL: - lttng_create_syscall_event_if_missing(event_enabler); + ret = lttng_event_enabler_create_syscall_events_if_missing(event_enabler); + WARN_ON_ONCE(ret); break; default: @@ -2317,7 +2186,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler_common *event_enab lttng_syscall_table_set_wildcard_all(event_enabler); /* First ensure that probe events are created for this enabler. */ - lttng_create_event_if_missing(event_enabler); + lttng_event_enabler_create_events_if_missing(event_enabler); /* Link the created event with its associated enabler. */ list_for_each_entry(event_priv, event_list_head, node) { @@ -2579,26 +2448,6 @@ void lttng_event_notifier_enabler_group_add(struct lttng_event_notifier_group *e 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) @@ -2782,9 +2631,11 @@ void lttng_sync_event_list(struct list_head *event_enabler_list, * Sync tracepoint registration with event enabled state. */ if (enabled) { - register_event(event); + if (!event_priv->registered) + register_event(event); } else { - _lttng_event_unregister(event); + if (event_priv->registered) + unregister_event(event); } lttng_event_sync_filter_state(event); @@ -2948,6 +2799,7 @@ void lttng_metadata_end(struct lttng_kernel_session *session) * The content of the printf is printed as a single atomic metadata * transaction. */ +static int lttng_metadata_printf(struct lttng_kernel_session *session, const char *fmt, ...) { @@ -3616,12 +3468,19 @@ int _lttng_fields_metadata_statedump(struct lttng_kernel_session *session, * transaction. */ static -int _lttng_event_metadata_statedump(struct lttng_kernel_session *session, - struct lttng_kernel_channel_buffer *chan, - struct lttng_kernel_event_recorder *event_recorder) +int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event) { + struct lttng_kernel_event_recorder *event_recorder; + struct lttng_kernel_channel_buffer *chan; + struct lttng_kernel_session *session; int ret = 0; + if (event->type != LTTNG_KERNEL_EVENT_TYPE_RECORDER) + return 0; + event_recorder = container_of(event, struct lttng_kernel_event_recorder, parent); + chan = event_recorder->chan; + session = chan->parent.session; + if (event_recorder->priv->metadata_dumped || !LTTNG_READ_ONCE(session->active)) return 0; if (chan->priv->channel_type == METADATA_CHANNEL) @@ -3805,20 +3664,12 @@ int64_t measure_clock_offset(void) uint64_t tcf = trace_clock_freq(); int64_t offset; unsigned long flags; -#ifdef LTTNG_KERNEL_HAS_TIMESPEC64 struct timespec64 rts = { 0, 0 }; -#else - struct timespec rts = { 0, 0 }; -#endif /* Disable interrupts to increase correlation precision. */ local_irq_save(flags); monotonic[0] = trace_clock_read64(); -#ifdef LTTNG_KERNEL_HAS_TIMESPEC64 ktime_get_real_ts64(&rts); -#else - getnstimeofday(&rts); -#endif monotonic[1] = trace_clock_read64(); local_irq_restore(flags); @@ -4076,8 +3927,7 @@ skip_session: } list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) { - ret = _lttng_event_metadata_statedump(session, event_recorder_priv->pub->chan, - event_recorder_priv->pub); + ret = _lttng_event_recorder_metadata_statedump(&event_recorder_priv->pub->parent); if (ret) goto end; } @@ -4279,13 +4129,7 @@ static int __init lttng_events_init(void) { int ret; - ret = wrapper_lttng_fixup_sig(THIS_MODULE); - if (ret) - return ret; ret = wrapper_get_pfnblock_flags_mask_init(); - if (ret) - return ret; - ret = wrapper_get_pageblock_flags_mask_init(); if (ret) return ret; ret = lttng_probes_init();