X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=lttng-probes.c;h=f95391fd0c0c3790c58ada4a82a4f8e43065f82a;hp=97dcc35908353fe7b56bf7e896fe9fd5c033e563;hb=9143c6d5444e809b9d411c07a8dae94c151668ae;hpb=a90917c3f8c4ed79117f1caa333b29a2108084ec diff --git a/lttng-probes.c b/lttng-probes.c index 97dcc359..f95391fd 100644 --- a/lttng-probes.c +++ b/lttng-probes.c @@ -1,11 +1,10 @@ -/* - * lttng-probes.c +/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1) * - * Copyright 2010-2011 (c) - Mathieu Desnoyers + * lttng-probes.c * * Holds LTTng probes registry. * - * Dual LGPL v2.1/GPL v2 license. + * Copyright (C) 2010-2012 Mathieu Desnoyers */ #include @@ -13,65 +12,215 @@ #include #include -#include "lttng-events.h" +#include + +/* + * probe list is protected by sessions lock. + */ +static LIST_HEAD(_probe_list); + +/* + * List of probes registered by not yet processed. + */ +static LIST_HEAD(lazy_probe_init); + +/* + * lazy_nesting counter ensures we don't trigger lazy probe registration + * fixup while we are performing the fixup. It is protected by the + * sessions lock. + */ +static int lazy_nesting; -static LIST_HEAD(probe_list); -static DEFINE_MUTEX(probe_mutex); +DEFINE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack); +EXPORT_PER_CPU_SYMBOL_GPL(lttng_dynamic_len_stack); + +/* + * Called under sessions lock. + */ static -const struct lttng_event_desc *find_event(const char *name) +int check_event_provider(struct lttng_probe_desc *desc) { - struct lttng_probe_desc *probe_desc; int i; + size_t provider_name_len; - list_for_each_entry(probe_desc, &probe_list, head) { - for (i = 0; i < probe_desc->nr_events; i++) { - if (!strcmp(probe_desc->event_desc[i]->name, name)) - return probe_desc->event_desc[i]; + provider_name_len = strnlen(desc->provider, + LTTNG_KERNEL_SYM_NAME_LEN - 1); + for (i = 0; i < desc->nr_events; i++) { + if (strncmp(desc->event_desc[i]->name, + desc->provider, + provider_name_len)) + return 0; /* provider mismatch */ + /* + * The event needs to contain at least provider name + _ + + * one or more letter. + */ + if (strlen(desc->event_desc[i]->name) <= provider_name_len + 1) + return 0; /* provider mismatch */ + if (desc->event_desc[i]->name[provider_name_len] != '_') + return 0; /* provider mismatch */ + } + return 1; +} + +/* + * Called under sessions lock. + */ +static +void lttng_lazy_probe_register(struct lttng_probe_desc *desc) +{ + struct lttng_probe_desc *iter; + struct list_head *probe_list; + + /* + * Each provider enforce that every event name begins with the + * provider name. Check this in an assertion for extra + * carefulness. This ensures we cannot have duplicate event + * names across providers. + */ + WARN_ON_ONCE(!check_event_provider(desc)); + + /* + * The provider ensures there are no duplicate event names. + * Duplicated TRACEPOINT_EVENT event names would generate a + * compile-time error due to duplicated symbol names. + */ + + /* + * We sort the providers by struct lttng_probe_desc pointer + * address. + */ + probe_list = &_probe_list; + list_for_each_entry_reverse(iter, probe_list, head) { + BUG_ON(iter == desc); /* Should never be in the list twice */ + if (iter < desc) { + /* We belong to the location right after iter. */ + list_add(&desc->head, &iter->head); + goto desc_added; } } + /* We should be added at the head of the list */ + list_add(&desc->head, probe_list); +desc_added: + pr_debug("LTTng: just registered probe %s containing %u events\n", + desc->provider, desc->nr_events); +} + +/* + * Called under sessions lock. + */ +static +void fixup_lazy_probes(void) +{ + struct lttng_probe_desc *iter, *tmp; + int ret; + + lazy_nesting++; + list_for_each_entry_safe(iter, tmp, + &lazy_probe_init, lazy_init_head) { + lttng_lazy_probe_register(iter); + iter->lazy = 0; + list_del(&iter->lazy_init_head); + } + ret = lttng_fix_pending_events(); + WARN_ON_ONCE(ret); + lazy_nesting--; +} + +/* + * Called under sessions lock. + */ +struct list_head *lttng_get_probe_list_head(void) +{ + if (!lazy_nesting && !list_empty(&lazy_probe_init)) + fixup_lazy_probes(); + return &_probe_list; +} + +static +const struct lttng_probe_desc *find_provider(const char *provider) +{ + struct lttng_probe_desc *iter; + struct list_head *probe_list; + + probe_list = lttng_get_probe_list_head(); + list_for_each_entry(iter, probe_list, head) { + if (!strcmp(iter->provider, provider)) + return iter; + } return NULL; } int lttng_probe_register(struct lttng_probe_desc *desc) { int ret = 0; - int i; - mutex_lock(&probe_mutex); + lttng_lock_sessions(); + /* - * TODO: This is O(N^2). Turn into a hash table when probe registration - * overhead becomes an issue. + * Check if the provider has already been registered. */ - for (i = 0; i < desc->nr_events; i++) { - if (find_event(desc->event_desc[i]->name)) { - ret = -EEXIST; - goto end; - } + if (find_provider(desc->provider)) { + ret = -EEXIST; + goto end; } - list_add(&desc->head, &probe_list); + list_add(&desc->lazy_init_head, &lazy_probe_init); + desc->lazy = 1; + pr_debug("LTTng: adding probe %s containing %u events to lazy registration list\n", + desc->provider, desc->nr_events); + /* + * If there is at least one active session, we need to register + * the probe immediately, since we cannot delay event + * registration because they are needed ASAP. + */ + if (lttng_session_active()) + fixup_lazy_probes(); end: - mutex_unlock(&probe_mutex); + lttng_unlock_sessions(); return ret; } EXPORT_SYMBOL_GPL(lttng_probe_register); void lttng_probe_unregister(struct lttng_probe_desc *desc) { - mutex_lock(&probe_mutex); - list_del(&desc->head); - mutex_unlock(&probe_mutex); + lttng_lock_sessions(); + if (!desc->lazy) + list_del(&desc->head); + else + list_del(&desc->lazy_init_head); + pr_debug("LTTng: just unregistered probe %s\n", desc->provider); + lttng_unlock_sessions(); } EXPORT_SYMBOL_GPL(lttng_probe_unregister); +/* + * TODO: this is O(nr_probes * nb_events), could be faster. + * Called with sessions lock held. + */ +static +const struct lttng_event_desc *find_event(const char *name) +{ + struct lttng_probe_desc *probe_desc; + int i; + + list_for_each_entry(probe_desc, &_probe_list, head) { + for (i = 0; i < probe_desc->nr_events; i++) { + if (!strcmp(probe_desc->event_desc[i]->name, name)) + return probe_desc->event_desc[i]; + } + } + return NULL; +} + +/* + * Called with sessions lock held. + */ const struct lttng_event_desc *lttng_event_get(const char *name) { const struct lttng_event_desc *event; int ret; - mutex_lock(&probe_mutex); event = find_event(name); - mutex_unlock(&probe_mutex); if (!event) return NULL; ret = try_module_get(event->owner); @@ -80,6 +229,9 @@ const struct lttng_event_desc *lttng_event_get(const char *name) } EXPORT_SYMBOL_GPL(lttng_event_get); +/* + * Called with sessions lock held. + */ void lttng_event_put(const struct lttng_event_desc *event) { module_put(event->owner); @@ -90,10 +242,12 @@ static void *tp_list_start(struct seq_file *m, loff_t *pos) { struct lttng_probe_desc *probe_desc; + struct list_head *probe_list; int iter = 0, i; - mutex_lock(&probe_mutex); - list_for_each_entry(probe_desc, &probe_list, head) { + lttng_lock_sessions(); + probe_list = lttng_get_probe_list_head(); + list_for_each_entry(probe_desc, probe_list, head) { for (i = 0; i < probe_desc->nr_events; i++) { if (iter++ >= *pos) return (void *) probe_desc->event_desc[i]; @@ -107,10 +261,12 @@ static void *tp_list_next(struct seq_file *m, void *p, loff_t *ppos) { struct lttng_probe_desc *probe_desc; + struct list_head *probe_list; int iter = 0, i; (*ppos)++; - list_for_each_entry(probe_desc, &probe_list, head) { + probe_list = lttng_get_probe_list_head(); + list_for_each_entry(probe_desc, probe_list, head) { for (i = 0; i < probe_desc->nr_events; i++) { if (iter++ >= *ppos) return (void *) probe_desc->event_desc[i]; @@ -123,7 +279,7 @@ void *tp_list_next(struct seq_file *m, void *p, loff_t *ppos) static void tp_list_stop(struct seq_file *m, void *p) { - mutex_unlock(&probe_mutex); + lttng_unlock_sessions(); } static @@ -131,11 +287,6 @@ int tp_list_show(struct seq_file *m, void *p) { const struct lttng_event_desc *probe_desc = p; - /* - * Don't export lttng internal events (metadata). - */ - if (!strncmp(probe_desc->name, "lttng_", sizeof("lttng_") - 1)) - return 0; seq_printf(m, "event { name = %s; };\n", probe_desc->name); return 0; @@ -162,3 +313,12 @@ const struct file_operations lttng_tracepoint_list_fops = { .llseek = seq_lseek, .release = seq_release, }; + +int lttng_probes_init(void) +{ + int cpu; + + for_each_possible_cpu(cpu) + per_cpu_ptr(<tng_dynamic_len_stack, cpu)->offset = 0; + return 0; +}