#include <linux/seq_file.h>
#include <lttng/events.h>
+#include <lttng/events-internal.h>
/*
* probe list is protected by sessions lock.
static LIST_HEAD(lazy_probe_init);
/*
- * lazy_nesting counter ensures we don't trigger lazy probe registration
+ * lazy_nesting counter ensures we don't notify lazy probe registration
* fixup while we are performing the fixup. It is protected by the
* sessions lock.
*/
* 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;
}
* 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;
/*
*/
/*
- * 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;
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);
}
/*
static
void fixup_lazy_probes(void)
{
- struct lttng_probe_desc *iter, *tmp;
+ struct lttng_kernel_probe_desc *iter, *tmp;
int ret;
lazy_nesting++;
}
ret = lttng_fix_pending_events();
WARN_ON_ONCE(ret);
+ ret = lttng_fix_pending_event_notifiers();
+ WARN_ON_ONCE(ret);
lazy_nesting--;
}
}
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;
/*
* 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
* registration because they are needed ASAP.
*/
- if (lttng_session_active())
+ if (lttng_session_active() || lttng_event_notifier_active())
fixup_lazy_probes();
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];
}
}
/*
* 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);
/*
* 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);
}
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;
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;
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;
}