* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#define _LGPL_SOURCE
#include <string.h>
#include <errno.h>
#include <urcu/list.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().
*/
static CDS_LIST_HEAD(_probe_list);
-struct cds_list_head *lttng_get_probe_list_head(void)
-{
- return &_probe_list;
-}
-
-static
-const struct lttng_probe_desc *find_provider(const char *provider)
-{
- struct lttng_probe_desc *iter;
- struct cds_list_head *probe_list;
+/*
+ * List of probes registered by not yet processed.
+ */
+static CDS_LIST_HEAD(lazy_probe_init);
- probe_list = lttng_get_probe_list_head();
- 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;
+/*
+ * Called under ust lock.
+ */
static
int check_event_provider(struct lttng_probe_desc *desc)
{
return 1;
}
-int lttng_probe_register(struct lttng_probe_desc *desc)
+/*
+ * Called under ust lock.
+ */
+static
+void lttng_lazy_probe_register(struct lttng_probe_desc *desc)
{
struct lttng_probe_desc *iter;
- int ret = 0;
- int i;
struct cds_list_head *probe_list;
- ust_lock();
-
- /*
- * Check if the provider has already been registered.
- */
- if (find_provider(desc->provider)) {
- ret = -EEXIST;
- goto end;
- }
-
/*
* Each provider enforce that every event name begins with the
* provider name. Check this in an assertion for extra
* We sort the providers by struct lttng_probe_desc pointer
* address.
*/
- probe_list = lttng_get_probe_list_head();
+ probe_list = &_probe_list;
cds_list_for_each_entry_reverse(iter, probe_list, head) {
BUG_ON(iter == desc); /* Should never be in the list twice */
if (iter < desc) {
desc_added:
DBG("just registered probe %s containing %u events",
desc->provider, desc->nr_events);
+}
+
+/*
+ * Called under ust lock.
+ */
+static
+void fixup_lazy_probes(void)
+{
+ struct lttng_probe_desc *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--;
+}
+
+/*
+ * Called under ust lock.
+ */
+struct cds_list_head *lttng_get_probe_list_head(void)
+{
+ if (!lazy_nesting && !cds_list_empty(&lazy_probe_init))
+ fixup_lazy_probes();
+ return &_probe_list;
+}
+
+static
+int check_provider_version(struct lttng_probe_desc *desc)
+{
/*
- * fix the events awaiting probe load.
+ * Check tracepoint provider version compatibility.
*/
- 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);
+ 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, 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, desc->major, desc->minor,
+ LTTNG_UST_PROVIDER_MAJOR,
+ LTTNG_UST_PROVIDER_MINOR);
+ return 0; /* reject */
}
-end:
+}
+
+
+int lttng_probe_register(struct lttng_probe_desc *desc)
+{
+ int ret = 0;
+
+ lttng_ust_fixup_tls();
+
+ /*
+ * 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 0;
+
+ ust_lock_nocheck();
+
+ cds_list_add(&desc->lazy_init_head, &lazy_probe_init);
+ desc->lazy = 1;
+ DBG("adding probe %s containing %u events to lazy registration list",
+ 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();
+
+ lttng_fix_pending_event_notifiers();
+
ust_unlock();
return ret;
}
void lttng_probe_unregister(struct lttng_probe_desc *desc)
{
- ust_lock();
- cds_list_del(&desc->head);
- DBG("just unregistered probe %s", desc->provider);
+ lttng_ust_fixup_tls();
+
+ if (!check_provider_version(desc))
+ return;
+
+ ust_lock_nocheck();
+ if (!desc->lazy)
+ cds_list_del(&desc->head);
+ else
+ cds_list_del(&desc->lazy_init_head);
+
+ lttng_probe_provider_unregister_events(desc);
+ DBG("just unregistered probes of provider %s", desc->provider);
+
ust_unlock();
}
list_entry->field.type = LTTNG_UST_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)
+ if (event_field->type.u.legacy.array.elem_type.atype != atype_integer
+ || event_field->type.u.legacy.array.elem_type.u.basic.integer.encoding == lttng_encode_none)
+ list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+ else
+ list_entry->field.type = LTTNG_UST_FIELD_STRING;
+ break;
+ case atype_array_nestable:
+ if (event_field->type.u.array_nestable.elem_type->atype != atype_integer
+ || event_field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none)
list_entry->field.type = LTTNG_UST_FIELD_OTHER;
else
list_entry->field.type = LTTNG_UST_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)
+ if (event_field->type.u.legacy.sequence.elem_type.atype != atype_integer
+ || event_field->type.u.legacy.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none)
+ list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+ else
+ list_entry->field.type = LTTNG_UST_FIELD_STRING;
+ break;
+ case atype_sequence_nestable:
+ if (event_field->type.u.sequence_nestable.elem_type->atype != atype_integer
+ || event_field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none)
list_entry->field.type = LTTNG_UST_FIELD_OTHER;
else
list_entry->field.type = LTTNG_UST_FIELD_STRING;
case atype_float:
list_entry->field.type = LTTNG_UST_FIELD_FLOAT;
break;
- case atype_enum:
+ case atype_enum: /* Fall-through */
+ case atype_enum_nestable:
list_entry->field.type = LTTNG_UST_FIELD_ENUM;
break;
default: