X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-probes.c;h=03fbe36b44d3f93c5701c5f1330e768efc9e2cdf;hb=4e48b5d;hp=e7dab9fce49c2603392a9362311aff3a88ee39d3;hpb=c0c0989ab70574e09b2f7e8b48c2da6af664a849;p=lttng-ust.git

diff --git a/liblttng-ust/lttng-probes.c b/liblttng-ust/lttng-probes.c
index e7dab9fc..03fbe36b 100644
--- a/liblttng-ust/lttng-probes.c
+++ b/liblttng-ust/lttng-probes.c
@@ -15,7 +15,7 @@
 #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"
@@ -41,42 +41,40 @@ static CDS_LIST_HEAD(lazy_probe_init);
 static int lazy_nesting;
 
 /*
- * Called under ust lock.
+ * Validate that each event within the probe provider refers to the
+ * right probe, and that the resulting name is not too long.
  */
 static
-int check_event_provider(struct lttng_probe_desc *desc)
+bool check_event_provider(const struct lttng_ust_probe_desc *probe_desc)
 {
 	int i;
-	size_t provider_name_len;
-
-	provider_name_len = strnlen(desc->provider,
-				LTTNG_UST_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 */
+
+	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 1;
+	return true;
 }
 
 /*
  * Called under ust lock.
  */
 static
-void lttng_lazy_probe_register(struct lttng_probe_desc *desc)
+void lttng_lazy_probe_register(struct lttng_ust_registered_probe *reg_probe)
 {
-	struct lttng_probe_desc *iter;
+	struct lttng_ust_registered_probe *iter;
 	struct cds_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.
-	 */
-	assert(check_event_provider(desc));
-
 	/*
 	 * The provider ensures there are no duplicate event names.
 	 * Duplicated TRACEPOINT_EVENT event names would generate a
@@ -84,23 +82,23 @@ 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_ust_probe_desc pointer
 	 * address.
 	 */
 	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) {
+		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(&reg_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(&reg_probe->head, probe_list);
+probe_added:
 	DBG("just registered probe %s containing %u events",
-		desc->provider, desc->nr_events);
+		reg_probe->desc->provider_name, reg_probe->desc->nr_events);
 }
 
 /*
@@ -109,7 +107,7 @@ desc_added:
 static
 void fixup_lazy_probes(void)
 {
-	struct lttng_probe_desc *iter, *tmp;
+	struct lttng_ust_registered_probe *iter, *tmp;
 	int ret;
 
 	lazy_nesting++;
@@ -135,7 +133,7 @@ struct cds_list_head *lttng_get_probe_list_head(void)
 }
 
 static
-int check_provider_version(struct lttng_probe_desc *desc)
+int check_provider_version(const struct lttng_ust_probe_desc *desc)
 {
 	/*
 	 * Check tracepoint provider version compatibility.
@@ -143,7 +141,7 @@ int check_provider_version(struct lttng_probe_desc *desc)
 	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,
+			desc->provider_name, desc->major, desc->minor,
 			LTTNG_UST_PROVIDER_MAJOR,
 			LTTNG_UST_PROVIDER_MINOR);
 		if (desc->major < LTTNG_UST_PROVIDER_MAJOR) {
@@ -156,17 +154,16 @@ int check_provider_version(struct lttng_probe_desc *desc)
 		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,
+			desc->provider_name, desc->major, desc->minor,
 			LTTNG_UST_PROVIDER_MAJOR,
 			LTTNG_UST_PROVIDER_MINOR);
 		return 0;		/* reject */
 	}
 }
 
-
-int lttng_probe_register(struct lttng_probe_desc *desc)
+struct lttng_ust_registered_probe *lttng_ust_probe_register(const struct lttng_ust_probe_desc *desc)
 {
-	int ret = 0;
+	struct lttng_ust_registered_probe *reg_probe = NULL;
 
 	lttng_ust_fixup_tls();
 
@@ -175,14 +172,21 @@ int lttng_probe_register(struct lttng_probe_desc *desc)
 	 * on caller. The version check just prints an error.
 	 */
 	if (!check_provider_version(desc))
-		return 0;
+		return NULL;
+	if (!check_event_provider(desc))
+		return NULL;
 
 	ust_lock_nocheck();
 
-	cds_list_add(&desc->lazy_init_head, &lazy_probe_init);
-	desc->lazy = 1;
+	reg_probe = zmalloc(sizeof(struct lttng_ust_registered_probe));
+	if (!reg_probe)
+		goto end;
+	reg_probe->desc = desc;
+	cds_list_add(&reg_probe->lazy_init_head, &lazy_probe_init);
+	reg_probe->lazy = 1;
+
 	DBG("adding probe %s containing %u events to lazy registration list",
-		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
@@ -192,28 +196,30 @@ int lttng_probe_register(struct lttng_probe_desc *desc)
 		fixup_lazy_probes();
 
 	lttng_fix_pending_event_notifiers();
-
+end:
 	ust_unlock();
-	return ret;
+	return reg_probe;
 }
 
-void lttng_probe_unregister(struct lttng_probe_desc *desc)
+void lttng_ust_probe_unregister(struct lttng_ust_registered_probe *reg_probe)
 {
 	lttng_ust_fixup_tls();
 
-	if (!check_provider_version(desc))
+	if (!reg_probe)
+		return;
+	if (!check_provider_version(reg_probe->desc))
 		return;
 
 	ust_lock_nocheck();
-	if (!desc->lazy)
-		cds_list_del(&desc->head);
+	if (!reg_probe->lazy)
+		cds_list_del(&reg_probe->head);
 	else
-		cds_list_del(&desc->lazy_init_head);
-
-	lttng_probe_provider_unregister_events(desc);
-	DBG("just unregistered probes of provider %s", desc->provider);
+		cds_list_del(&reg_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)
@@ -231,28 +237,32 @@ 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;
-	int i;
+	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);
 			}
 		}
 	}
@@ -272,7 +282,7 @@ err_nomem:
  * 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;
@@ -303,15 +313,17 @@ void lttng_probes_prune_field_list(struct lttng_ust_field_list *list)
  */
 int lttng_probes_get_field_list(struct lttng_ust_field_list *list)
 {
-	struct lttng_probe_desc *probe_desc;
-	int i;
+	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;
 
@@ -319,16 +331,16 @@ int lttng_probes_get_field_list(struct lttng_ust_field_list *list)
 				/* 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 {
@@ -338,66 +350,49 @@ int lttng_probes_get_field_list(struct lttng_ust_field_list *list)
 			}
 
 			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;
-					break;
-				case atype_string:
-					list_entry->field.type = LTTNG_UST_FIELD_STRING;
+					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_array:
-					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;
+				case lttng_ust_type_string:
+					list_entry->field.type = LTTNG_UST_ABI_FIELD_STRING;
 					break;
-				case atype_sequence:
-					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;
+				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_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;
+				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:	/* Fall-through */
-				case atype_enum_nestable:
-					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;
@@ -425,7 +420,7 @@ err_nomem:
  * 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;