X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=src%2Flttng-probes.c;h=73d9482d0f1ee41d3c4621127c2c1d559942230f;hb=HEAD;hp=3033094bbb88f6ec4e43d3d319dd422e339c64fa;hpb=196bfc6a04f069e57803c9a2a18f2528394ceacd;p=lttng-modules.git diff --git a/src/lttng-probes.c b/src/lttng-probes.c index 3033094b..73d9482d 100644 --- a/src/lttng-probes.c +++ b/src/lttng-probes.c @@ -13,6 +13,7 @@ #include #include +#include /* * probe list is protected by sessions lock. @@ -39,26 +40,33 @@ EXPORT_PER_CPU_SYMBOL_GPL(lttng_dynamic_len_stack); * Called under sessions lock. */ static -int check_event_provider(struct lttng_probe_desc *desc) +int check_event_provider(struct lttng_kernel_probe_desc *desc) { - int i; + int i, mismatch = 0; size_t provider_name_len; - provider_name_len = strnlen(desc->provider, - LTTNG_KERNEL_SYM_NAME_LEN - 1); + provider_name_len = strnlen(desc->provider_name, + LTTNG_KERNEL_ABI_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 + _ + + * The event name needs to start with 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 */ + if (strncmp(desc->event_desc[i]->event_name, desc->provider_name, provider_name_len)) + mismatch = 1; + else if (strlen(desc->event_desc[i]->event_name) <= provider_name_len + 1) + mismatch = 1; + else if (desc->event_desc[i]->event_name[provider_name_len] != '_') + mismatch = 1; + + if (mismatch) { + printk(KERN_WARNING "LTTng: event provider mismatch: " + "The event name needs to start with provider " + "name + _ + one or more letter, " + "provider: %s, event name: %s\n", + desc->provider_name, desc->event_desc[i]->event_name); + return 0; + } } return 1; } @@ -67,9 +75,9 @@ int check_event_provider(struct lttng_probe_desc *desc) * Called under sessions lock. */ static -void lttng_lazy_probe_register(struct lttng_probe_desc *desc) +void lttng_lazy_probe_register(struct lttng_kernel_probe_desc *desc) { - struct lttng_probe_desc *iter; + struct lttng_kernel_probe_desc *iter; struct list_head *probe_list; /* @@ -87,7 +95,7 @@ void lttng_lazy_probe_register(struct lttng_probe_desc *desc) */ /* - * We sort the providers by struct lttng_probe_desc pointer + * We sort the providers by struct lttng_kernel_probe_desc pointer * address. */ probe_list = &_probe_list; @@ -103,7 +111,7 @@ void lttng_lazy_probe_register(struct lttng_probe_desc *desc) list_add(&desc->head, probe_list); desc_added: pr_debug("LTTng: just registered probe %s containing %u events\n", - desc->provider, desc->nr_events); + desc->provider_name, desc->nr_events); } /* @@ -112,7 +120,7 @@ desc_added: static void fixup_lazy_probes(void) { - struct lttng_probe_desc *iter, *tmp; + struct lttng_kernel_probe_desc *iter, *tmp; int ret; lazy_nesting++; @@ -140,20 +148,20 @@ struct list_head *lttng_get_probe_list_head(void) } static -const struct lttng_probe_desc *find_provider(const char *provider) +const struct lttng_kernel_probe_desc *find_provider(const char *provider) { - struct lttng_probe_desc *iter; + struct lttng_kernel_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)) + if (!strcmp(iter->provider_name, provider)) return iter; } return NULL; } -int lttng_probe_register(struct lttng_probe_desc *desc) +int lttng_kernel_probe_register(struct lttng_kernel_probe_desc *desc) { int ret = 0; @@ -162,14 +170,14 @@ int lttng_probe_register(struct lttng_probe_desc *desc) /* * Check if the provider has already been registered. */ - if (find_provider(desc->provider)) { + if (find_provider(desc->provider_name)) { ret = -EEXIST; goto end; } 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); + desc->provider_name, desc->nr_events); /* * If there is at least one active session, we need to register * the probe immediately, since we cannot delay event @@ -181,33 +189,33 @@ end: lttng_unlock_sessions(); return ret; } -EXPORT_SYMBOL_GPL(lttng_probe_register); +EXPORT_SYMBOL_GPL(lttng_kernel_probe_register); -void lttng_probe_unregister(struct lttng_probe_desc *desc) +void lttng_kernel_probe_unregister(struct lttng_kernel_probe_desc *desc) { 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); + pr_debug("LTTng: just unregistered probe %s\n", desc->provider_name); lttng_unlock_sessions(); } -EXPORT_SYMBOL_GPL(lttng_probe_unregister); +EXPORT_SYMBOL_GPL(lttng_kernel_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_desc(const char *name) +const struct lttng_kernel_event_desc *find_event_desc(const char *name) { - struct lttng_probe_desc *probe_desc; + struct lttng_kernel_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)) + if (!strcmp(probe_desc->event_desc[i]->event_name, name)) return probe_desc->event_desc[i]; } } @@ -217,9 +225,9 @@ const struct lttng_event_desc *find_event_desc(const char *name) /* * Called with sessions lock held. */ -const struct lttng_event_desc *lttng_event_desc_get(const char *name) +const struct lttng_kernel_event_desc *lttng_event_desc_get(const char *name) { - const struct lttng_event_desc *event_desc; + const struct lttng_kernel_event_desc *event_desc; int ret; event_desc = find_event_desc(name); @@ -234,7 +242,7 @@ EXPORT_SYMBOL_GPL(lttng_event_desc_get); /* * Called with sessions lock held. */ -void lttng_event_desc_put(const struct lttng_event_desc *event_desc) +void lttng_event_desc_put(const struct lttng_kernel_event_desc *event_desc) { module_put(event_desc->owner); } @@ -243,7 +251,7 @@ EXPORT_SYMBOL_GPL(lttng_event_desc_put); static void *tp_list_start(struct seq_file *m, loff_t *pos) { - struct lttng_probe_desc *probe_desc; + struct lttng_kernel_probe_desc *probe_desc; struct list_head *probe_list; int iter = 0, i; @@ -262,7 +270,7 @@ void *tp_list_start(struct seq_file *m, loff_t *pos) static void *tp_list_next(struct seq_file *m, void *p, loff_t *ppos) { - struct lttng_probe_desc *probe_desc; + struct lttng_kernel_probe_desc *probe_desc; struct list_head *probe_list; int iter = 0, i; @@ -287,10 +295,10 @@ void tp_list_stop(struct seq_file *m, void *p) static int tp_list_show(struct seq_file *m, void *p) { - const struct lttng_event_desc *probe_desc = p; + const struct lttng_kernel_event_desc *probe_desc = p; seq_printf(m, "event { name = %s; };\n", - probe_desc->name); + probe_desc->event_name); return 0; }