/*
- * lttng-probes.c
+ * SPDX-License-Identifier: LGPL-2.1-only
*
- * Holds LTTng probes registry.
- *
- * Copyright 2010-2012 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
+ * Copyright 2010-2012 (C) Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
*
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Holds LTTng probes registry.
*/
+#define _LGPL_SOURCE
#include <string.h>
#include <errno.h>
#include <urcu/list.h>
#include <lttng/tracepoint.h>
#include "tracepoint-internal.h"
#include <assert.h>
-#include <helper.h>
+#include <ust-helper.h>
#include <ctype.h>
#include "lttng-tracer-core.h"
#include "jhash.h"
#include "error.h"
+#include "ust-events-internal.h"
/*
* probe list is protected by ust_lock()/ust_unlock().
*/
-CDS_LIST_HEAD(probe_list);
-
-struct cds_list_head *lttng_get_probe_list_head(void)
-{
- return &probe_list;
-}
+static CDS_LIST_HEAD(_probe_list);
-static
-const struct lttng_probe_desc *find_provider(const char *provider)
-{
- struct lttng_probe_desc *iter;
+/*
+ * List of probes registered by not yet processed.
+ */
+static CDS_LIST_HEAD(lazy_probe_init);
- cds_list_for_each_entry(iter, &probe_list, head) {
- if (!strcmp(iter->provider, provider))
- return iter;
- }
- return NULL;
-}
+/*
+ * lazy_nesting counter ensures we don't trigger lazy probe registration
+ * fixup while we are performing the fixup. It is protected by the ust
+ * mutex.
+ */
+static int lazy_nesting;
+/*
+ * Validate that each event within the probe provider refers to the
+ * right probe, and that the resulting name is not too long.
+ */
static
-const struct lttng_event_desc *find_event(const char *name)
+bool check_event_provider(const struct lttng_ust_probe_desc *probe_desc)
{
- struct lttng_probe_desc *probe_desc;
int i;
- cds_list_for_each_entry(probe_desc, &probe_list, head) {
- for (i = 0; i < probe_desc->nr_events; i++) {
- if (!strncmp(probe_desc->event_desc[i]->name, name,
- LTTNG_UST_SYM_NAME_LEN - 1))
- return probe_desc->event_desc[i];
+ for (i = 0; i < probe_desc->nr_events; i++) {
+ const struct lttng_ust_event_desc *event_desc = probe_desc->event_desc[i];
+
+ if (event_desc->probe_desc != probe_desc) {
+ ERR("Error registering probe provider '%s'. Event '%s:%s' refers to the wrong provider descriptor.",
+ probe_desc->provider_name, probe_desc->provider_name, event_desc->event_name);
+ return false; /* provider mismatch */
+ }
+ if (!lttng_ust_validate_event_name(event_desc)) {
+ ERR("Error registering probe provider '%s'. Event '%s:%s' name is too long.",
+ probe_desc->provider_name, probe_desc->provider_name, event_desc->event_name);
+ return false; /* provider mismatch */
}
}
- return NULL;
+ return true;
}
-int lttng_probe_register(struct lttng_probe_desc *desc)
+/*
+ * Called under ust lock.
+ */
+static
+void lttng_lazy_probe_register(struct lttng_ust_registered_probe *reg_probe)
{
- struct lttng_probe_desc *iter;
- int ret = 0;
- int i;
+ struct lttng_ust_registered_probe *iter;
+ struct cds_list_head *probe_list;
- ust_lock();
- if (find_provider(desc->provider)) {
- ret = -EEXIST;
- goto end;
- }
/*
- * TODO: This is O(N^2). Turn into a hash table when probe registration
- * overhead becomes an issue.
+ * 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.
*/
- for (i = 0; i < desc->nr_events; i++) {
- if (find_event(desc->event_desc[i]->name)) {
- ret = -EEXIST;
- goto end;
- }
- }
/*
- * We sort the providers by struct lttng_probe_desc pointer
+ * We sort the providers by struct lttng_ust_probe_desc pointer
* address.
*/
- cds_list_for_each_entry_reverse(iter, &probe_list, head) {
- BUG_ON(iter == desc); /* Should never be in the list twice */
- if (iter < desc) {
+ probe_list = &_probe_list;
+ cds_list_for_each_entry_reverse(iter, probe_list, head) {
+ BUG_ON(iter == reg_probe); /* Should never be in the list twice */
+ if (iter < reg_probe) {
/* We belong to the location right after iter. */
- cds_list_add(&desc->head, &iter->head);
- goto desc_added;
+ cds_list_add(®_probe->head, &iter->head);
+ goto probe_added;
}
}
/* We should be added at the head of the list */
- cds_list_add(&desc->head, &probe_list);
-desc_added:
+ cds_list_add(®_probe->head, probe_list);
+probe_added:
DBG("just registered probe %s containing %u events",
- desc->provider, desc->nr_events);
- /*
- * fix the events awaiting probe load.
- */
- for (i = 0; i < desc->nr_events; i++) {
- const struct lttng_event_desc *ed;
-
- ed = desc->event_desc[i];
- DBG("Registered event probe \"%s\" with signature \"%s\"",
- ed->name, ed->signature);
- ret = lttng_fix_pending_event_desc(ed);
- assert(!ret);
- }
-end:
- ust_unlock();
- return ret;
+ reg_probe->desc->provider_name, reg_probe->desc->nr_events);
}
-/* Backward compatibility with UST 2.0 */
-int ltt_probe_register(struct lttng_probe_desc *desc)
+/*
+ * Called under ust lock.
+ */
+static
+void fixup_lazy_probes(void)
{
- return lttng_probe_register(desc);
+ struct lttng_ust_registered_probe *iter, *tmp;
+ int ret;
+
+ lazy_nesting++;
+ cds_list_for_each_entry_safe(iter, tmp,
+ &lazy_probe_init, lazy_init_head) {
+ lttng_lazy_probe_register(iter);
+ iter->lazy = 0;
+ cds_list_del(&iter->lazy_init_head);
+ }
+ ret = lttng_fix_pending_events();
+ assert(!ret);
+ lazy_nesting--;
}
-void lttng_probe_unregister(struct lttng_probe_desc *desc)
+/*
+ * Called under ust lock.
+ */
+struct cds_list_head *lttng_get_probe_list_head(void)
{
- ust_lock();
- cds_list_del(&desc->head);
- DBG("just unregistered probe %s", desc->provider);
- ust_unlock();
+ if (!lazy_nesting && !cds_list_empty(&lazy_probe_init))
+ fixup_lazy_probes();
+ return &_probe_list;
}
-/* Backward compatibility with UST 2.0 */
-void ltt_probe_unregister(struct lttng_probe_desc *desc)
+static
+int check_provider_version(const struct lttng_ust_probe_desc *desc)
{
- lttng_probe_unregister(desc);
+ /*
+ * Check tracepoint provider version compatibility.
+ */
+ if (desc->major <= LTTNG_UST_PROVIDER_MAJOR) {
+ DBG("Provider \"%s\" accepted, version %u.%u is compatible "
+ "with LTTng UST provider version %u.%u.",
+ desc->provider_name, desc->major, desc->minor,
+ LTTNG_UST_PROVIDER_MAJOR,
+ LTTNG_UST_PROVIDER_MINOR);
+ if (desc->major < LTTNG_UST_PROVIDER_MAJOR) {
+ DBG("However, some LTTng UST features might not be "
+ "available for this provider unless it is "
+ "recompiled against a more recent LTTng UST.");
+ }
+ return 1; /* accept */
+ } else {
+ ERR("Provider \"%s\" rejected, version %u.%u is incompatible "
+ "with LTTng UST provider version %u.%u. Please upgrade "
+ "LTTng UST.",
+ desc->provider_name, desc->major, desc->minor,
+ LTTNG_UST_PROVIDER_MAJOR,
+ LTTNG_UST_PROVIDER_MINOR);
+ return 0; /* reject */
+ }
}
-/*
- * called with UST lock held.
- */
-const struct lttng_event_desc *lttng_event_get(const char *name)
+struct lttng_ust_registered_probe *lttng_ust_probe_register(const struct lttng_ust_probe_desc *desc)
{
- const struct lttng_event_desc *event;
+ struct lttng_ust_registered_probe *reg_probe = NULL;
+
+ lttng_ust_fixup_tls();
- event = find_event(name);
- if (!event)
+ /*
+ * If version mismatch, don't register, but don't trigger assert
+ * on caller. The version check just prints an error.
+ */
+ if (!check_provider_version(desc))
return NULL;
- return event;
+ if (!check_event_provider(desc))
+ return NULL;
+
+ ust_lock_nocheck();
+
+ reg_probe = zmalloc(sizeof(struct lttng_ust_registered_probe));
+ if (!reg_probe)
+ goto end;
+ reg_probe->desc = desc;
+ cds_list_add(®_probe->lazy_init_head, &lazy_probe_init);
+ reg_probe->lazy = 1;
+
+ DBG("adding probe %s containing %u events to lazy registration list",
+ 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())
+ fixup_lazy_probes();
+
+ lttng_fix_pending_event_notifiers();
+end:
+ ust_unlock();
+ return reg_probe;
}
-void lttng_event_put(const struct lttng_event_desc *event)
+void lttng_ust_probe_unregister(struct lttng_ust_registered_probe *reg_probe)
{
+ lttng_ust_fixup_tls();
+
+ if (!reg_probe)
+ return;
+ if (!check_provider_version(reg_probe->desc))
+ return;
+
+ ust_lock_nocheck();
+ if (!reg_probe->lazy)
+ cds_list_del(®_probe->head);
+ else
+ cds_list_del(®_probe->lazy_init_head);
+
+ lttng_probe_provider_unregister_events(reg_probe->desc);
+ DBG("just unregistered probes of provider %s", reg_probe->desc->provider_name);
+ ust_unlock();
+ free(reg_probe);
}
void lttng_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
*/
int lttng_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
{
- struct lttng_probe_desc *probe_desc;
+ struct lttng_ust_registered_probe *reg_probe;
+ struct cds_list_head *probe_list;
int i;
+ probe_list = lttng_get_probe_list_head();
CDS_INIT_LIST_HEAD(&list->head);
- cds_list_for_each_entry(probe_desc, &probe_list, head) {
+ cds_list_for_each_entry(reg_probe, probe_list, head) {
+ const struct lttng_ust_probe_desc *probe_desc = reg_probe->desc;
+
for (i = 0; i < probe_desc->nr_events; i++) {
+ const struct lttng_ust_event_desc *event_desc =
+ probe_desc->event_desc[i];
struct tp_list_entry *list_entry;
+ /* Skip event if name is too long. */
+ if (!lttng_ust_validate_event_name(event_desc))
+ continue;
list_entry = zmalloc(sizeof(*list_entry));
if (!list_entry)
goto err_nomem;
cds_list_add(&list_entry->head, &list->head);
- strncpy(list_entry->tp.name,
- probe_desc->event_desc[i]->name,
- LTTNG_UST_SYM_NAME_LEN);
- list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- if (!probe_desc->event_desc[i]->loglevel) {
+ lttng_ust_format_event_name(event_desc, list_entry->tp.name);
+ if (!event_desc->loglevel) {
list_entry->tp.loglevel = TRACE_DEFAULT;
} else {
- list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel);
+ list_entry->tp.loglevel = *(*event_desc->loglevel);
}
}
}
* Return current iteration position, advance internal iterator to next.
* Return NULL if end of list.
*/
-struct lttng_ust_tracepoint_iter *
+struct lttng_ust_abi_tracepoint_iter *
lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
{
struct tp_list_entry *entry;
*/
int lttng_probes_get_field_list(struct lttng_ust_field_list *list)
{
- struct lttng_probe_desc *probe_desc;
+ struct lttng_ust_registered_probe *reg_probe;
+ struct cds_list_head *probe_list;
int i;
+ probe_list = lttng_get_probe_list_head();
CDS_INIT_LIST_HEAD(&list->head);
- cds_list_for_each_entry(probe_desc, &probe_list, head) {
+ cds_list_for_each_entry(reg_probe, probe_list, head) {
+ const struct lttng_ust_probe_desc *probe_desc = reg_probe->desc;
+
for (i = 0; i < probe_desc->nr_events; i++) {
- const struct lttng_event_desc *event_desc =
+ const struct lttng_ust_event_desc *event_desc =
probe_desc->event_desc[i];
int j;
/* Events without fields. */
struct tp_field_list_entry *list_entry;
+ /* Skip event if name is too long. */
+ if (!lttng_ust_validate_event_name(event_desc))
+ continue;
list_entry = zmalloc(sizeof(*list_entry));
if (!list_entry)
goto err_nomem;
cds_list_add(&list_entry->head, &list->head);
- strncpy(list_entry->field.event_name,
- event_desc->name,
- LTTNG_UST_SYM_NAME_LEN);
- list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ lttng_ust_format_event_name(event_desc, list_entry->field.event_name);
list_entry->field.field_name[0] = '\0';
- list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_OTHER;
if (!event_desc->loglevel) {
list_entry->field.loglevel = TRACE_DEFAULT;
} else {
}
for (j = 0; j < event_desc->nr_fields; j++) {
- const struct lttng_event_field *event_field =
- &event_desc->fields[j];
+ const struct lttng_ust_event_field *event_field =
+ event_desc->fields[j];
struct tp_field_list_entry *list_entry;
+ /* Skip event if name is too long. */
+ if (!lttng_ust_validate_event_name(event_desc))
+ continue;
list_entry = zmalloc(sizeof(*list_entry));
if (!list_entry)
goto err_nomem;
cds_list_add(&list_entry->head, &list->head);
- strncpy(list_entry->field.event_name,
- event_desc->name,
- LTTNG_UST_SYM_NAME_LEN);
- list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ lttng_ust_format_event_name(event_desc, list_entry->field.event_name);
strncpy(list_entry->field.field_name,
event_field->name,
- LTTNG_UST_SYM_NAME_LEN);
- list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- switch (event_field->type.atype) {
- case atype_integer:
- list_entry->field.type = LTTNG_UST_FIELD_INTEGER;
+ LTTNG_UST_ABI_SYM_NAME_LEN);
+ list_entry->field.field_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ switch (event_field->type->type) {
+ case lttng_ust_type_integer:
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_INTEGER;
break;
- case atype_string:
- list_entry->field.type = LTTNG_UST_FIELD_STRING;
+ case lttng_ust_type_string:
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_STRING;
break;
- case atype_array:
- if (event_field->type.u.array.elem_type.atype != atype_integer
- || event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none)
- list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+ case lttng_ust_type_array:
+ if (lttng_ust_get_type_array(event_field->type)->encoding == lttng_ust_string_encoding_none)
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_OTHER;
else
- list_entry->field.type = LTTNG_UST_FIELD_STRING;
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_STRING;
break;
- case atype_sequence:
- if (event_field->type.u.sequence.elem_type.atype != atype_integer
- || event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none)
- list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+ case lttng_ust_type_sequence:
+ if (lttng_ust_get_type_sequence(event_field->type)->encoding == lttng_ust_string_encoding_none)
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_OTHER;
else
- list_entry->field.type = LTTNG_UST_FIELD_STRING;
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_STRING;
break;
- case atype_float:
- list_entry->field.type = LTTNG_UST_FIELD_FLOAT;
+ case lttng_ust_type_float:
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_FLOAT;
break;
- case atype_enum:
- list_entry->field.type = LTTNG_UST_FIELD_ENUM;
+ case lttng_ust_type_enum:
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_ENUM;
break;
default:
- list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+ list_entry->field.type = LTTNG_UST_ABI_FIELD_OTHER;
}
if (!event_desc->loglevel) {
list_entry->field.loglevel = TRACE_DEFAULT;
* Return current iteration position, advance internal iterator to next.
* Return NULL if end of list.
*/
-struct lttng_ust_field_iter *
+struct lttng_ust_abi_field_iter *
lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
{
struct tp_field_list_entry *entry;
projects / lttng-ust.git / blobdiff