X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Fltt-probes.c;h=8ccb6fab9d2f32c37e2c14fa945adbcb38a9b54e;hb=5cc698637adec84638150b34c7f77192e9cd5297;hp=2994512825660596060f8875915c026d3f01dc71;hpb=574a6217af27f0e1ca8998790ce7744684d83168;p=lttng-ust.git

diff --git a/liblttng-ust/ltt-probes.c b/liblttng-ust/ltt-probes.c
index 29945128..8ccb6fab 100644
--- a/liblttng-ust/ltt-probes.c
+++ b/liblttng-ust/ltt-probes.c
@@ -1,11 +1,23 @@
 /*
  * ltt-probes.c
  *
- * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
  * Holds LTTng probes registry.
  *
- * Dual LGPL v2.1/GPL v2 license.
+ * 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.
+ *
+ * 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
  */
 
 #include <string.h>
@@ -13,8 +25,11 @@
 #include <urcu/list.h>
 #include <urcu/hlist.h>
 #include <lttng/ust-events.h>
+#include <lttng/tracepoint.h>
+#include "tracepoint-internal.h"
 #include <assert.h>
 #include <helper.h>
+#include <ctype.h>
 
 #include "ltt-tracer-core.h"
 #include "jhash.h"
@@ -25,14 +40,6 @@
  */
 static CDS_LIST_HEAD(probe_list);
 
-/*
- * Loglevel hash table, containing the active loglevels.
- * Protected by ust lock.
- */
-#define LOGLEVEL_HASH_BITS 6
-#define LOGLEVEL_TABLE_SIZE (1 << LOGLEVEL_HASH_BITS)
-static struct cds_hlist_head loglevel_table[LOGLEVEL_TABLE_SIZE];
-
 static
 const struct lttng_probe_desc *find_provider(const char *provider)
 {
@@ -53,7 +60,8 @@ const struct lttng_event_desc *find_event(const char *name)
 
 	cds_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 (!strncmp(probe_desc->event_desc[i]->name, name,
+					LTTNG_UST_SYM_NAME_LEN - 1))
 				return probe_desc->event_desc[i];
 		}
 	}
@@ -97,12 +105,18 @@ int ltt_probe_register(struct lttng_probe_desc *desc)
 	/* We should be added at the head of the list */
 	cds_list_add(&desc->head, &probe_list);
 desc_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++) {
-		ret = pending_probe_fix_events(desc->event_desc[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 = pending_probe_fix_events(ed);
 		assert(!ret);
 	}
 end:
@@ -114,6 +128,7 @@ void ltt_probe_unregister(struct lttng_probe_desc *desc)
 {
 	ust_lock();
 	cds_list_del(&desc->head);
+	DBG("just unregistered probe %s", desc->provider);
 	ust_unlock();
 }
 
@@ -166,15 +181,9 @@ int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
 				LTTNG_UST_SYM_NAME_LEN);
 			list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 			if (!probe_desc->event_desc[i]->loglevel) {
-				list_entry->tp.loglevel[0] = '\0';
-				list_entry->tp.loglevel_value = 0;
+				list_entry->tp.loglevel = TRACE_DEFAULT;
 			} else {
-				strncpy(list_entry->tp.loglevel,
-					(*probe_desc->event_desc[i]->loglevel)->identifier,
-					LTTNG_UST_SYM_NAME_LEN);
-				list_entry->tp.loglevel[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-				list_entry->tp.loglevel_value =
-					(*probe_desc->event_desc[i]->loglevel)->value;
+				list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel);
 			}
 		}
 	}
@@ -210,178 +219,169 @@ struct lttng_ust_tracepoint_iter *
 	return &entry->tp;
 }
 
-/*
- * Get loglevel if the loglevel is present in the loglevel hash table.
- * Must be called with ust lock held.
- * Returns NULL if not present.
- */
-struct loglevel_entry *get_loglevel(const char *name)
+void ltt_probes_prune_field_list(struct lttng_ust_field_list *list)
 {
-	struct cds_hlist_head *head;
-	struct cds_hlist_node *node;
-	struct loglevel_entry *e;
-	uint32_t hash = jhash(name, strlen(name), 0);
-
-	head = &loglevel_table[hash & (LOGLEVEL_TABLE_SIZE - 1)];
-	cds_hlist_for_each_entry(e, node, head, hlist) {
-		if (!strcmp(name, e->name))
-			return e;
+	struct tp_field_list_entry *list_entry, *tmp;
+
+	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
+		cds_list_del(&list_entry->head);
+		free(list_entry);
 	}
-	return NULL;
 }
 
 /*
- * marshall all probes/all events and create those that fit the
- * loglevel. Add them to the events list as created.
+ * called with UST lock held.
  */
-static
-void _probes_create_loglevel_events(struct loglevel_entry *entry,
-				struct session_loglevel *loglevel)
+int ltt_probes_get_field_list(struct lttng_ust_field_list *list)
 {
 	struct lttng_probe_desc *probe_desc;
 	int i;
 
+	CDS_INIT_LIST_HEAD(&list->head);
 	cds_list_for_each_entry(probe_desc, &probe_list, head) {
 		for (i = 0; i < probe_desc->nr_events; i++) {
-			const struct tracepoint_loglevel_entry *ev_ll;
-
-			if (!(probe_desc->event_desc[i]->loglevel))
-				continue;
-			ev_ll = *probe_desc->event_desc[i]->loglevel;
-			if (!strcmp(ev_ll->identifier, entry->name)) {
-				struct ltt_event *ev;
-				int ret;
-
-				/* create event */
-				ret = ltt_event_create(loglevel->chan,
-					&loglevel->event_param, NULL,
-					&ev);
-				/*
-				 * TODO: report error.
-				 */
-				if (ret)
-					continue;
-				cds_list_add(&ev->loglevel_list,
-					&loglevel->events);
+			const struct lttng_event_desc *event_desc =
+				probe_desc->event_desc[i];
+			int j;
+
+			for (j = 0; j < event_desc->nr_fields; j++) {
+				const struct lttng_event_field *event_field =
+					&event_desc->fields[j];
+				struct tp_field_list_entry *list_entry;
+
+				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';
+				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;
+					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;
+					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)
+						list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+					else
+						list_entry->field.type = LTTNG_UST_FIELD_STRING;
+					break;
+				case atype_float:
+					list_entry->field.type = LTTNG_UST_FIELD_FLOAT;
+					break;
+				case atype_enum:
+					list_entry->field.type = LTTNG_UST_FIELD_ENUM;
+					break;
+				default:
+					list_entry->field.type = LTTNG_UST_FIELD_OTHER;
+				}
+				if (!event_desc->loglevel) {
+					list_entry->field.loglevel = TRACE_DEFAULT;
+				} else {
+					list_entry->field.loglevel = *(*event_desc->loglevel);
+				}
 			}
 		}
 	}
+	if (cds_list_empty(&list->head))
+		list->iter = NULL;
+	else
+		list->iter =
+			cds_list_first_entry(&list->head,
+				struct tp_field_list_entry, head);
+	return 0;
+
+err_nomem:
+	ltt_probes_prune_field_list(list);
+	return -ENOMEM;
 }
 
 /*
- * Add the loglevel to the loglevel hash table. Must be called with
- * ust lock held.
+ * Return current iteration position, advance internal iterator to next.
+ * Return NULL if end of list.
  */
-struct session_loglevel *add_loglevel(const char *name,
-	struct ltt_channel *chan,
-	struct lttng_ust_event *event_param)
+struct lttng_ust_field_iter *
+	lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
 {
-	struct cds_hlist_head *head;
-	struct cds_hlist_node *node;
-	struct loglevel_entry *e;
-	struct session_loglevel *sl;
-	size_t name_len = strlen(name) + 1;
-	uint32_t hash = jhash(name, name_len-1, 0);
-	int found = 0;
-
-	/* loglevel entry */
-	head = &loglevel_table[hash & (LOGLEVEL_TABLE_SIZE - 1)];
-	cds_hlist_for_each_entry(e, node, head, hlist) {
-		if (!strcmp(name, e->name)) {
-			found = 1;
-			break;
-		}
-	}
-
-	if (!found) {
-		/*
-		 * Using zmalloc here to allocate a variable length element. Could
-		 * cause some memory fragmentation if overused.
-		 */
-		e = zmalloc(sizeof(struct loglevel_entry) + name_len);
-		if (!e)
-			return ERR_PTR(-ENOMEM);
-		memcpy(&e->name[0], name, name_len);
-		cds_hlist_add_head(&e->hlist, head);
-	}
+	struct tp_field_list_entry *entry;
 
-	/* session loglevel */
-	cds_list_for_each_entry(sl, &e->session_list, session_list) {
-		if (chan == sl->chan) {
-			DBG("loglevel %s busy for this channel", name);
-			return ERR_PTR(-EEXIST);	/* Already there */
-		}
-	}
-	sl = zmalloc(sizeof(struct session_loglevel));
-	if (!sl)
-		return ERR_PTR(-ENOMEM);
-	sl->chan = chan;
-	sl->enabled = 1;
-	memcpy(&sl->event_param, event_param, sizeof(sl->event_param));
-	CDS_INIT_LIST_HEAD(&sl->events);
-	cds_list_add(&sl->list, &chan->session->loglevels);
-	cds_list_add(&sl->session_list, &e->session_list);
-	_probes_create_loglevel_events(e, sl);
-	return sl;
+	if (!list->iter)
+		return NULL;
+	entry = list->iter;
+	if (entry->head.next == &list->head)
+		list->iter = NULL;
+	else
+		list->iter = cds_list_entry(entry->head.next,
+				struct tp_field_list_entry, head);
+	return &entry->field;
 }
 
 /*
- * Remove the loglevel from the loglevel hash table. Must be called with
- * ust_lock held. Only called at session teardown.
+ * marshall all probes/all events and create those that fit the
+ * wildcard. Add them to the events list as created.
  */
-void _remove_loglevel(struct session_loglevel *loglevel)
+void ltt_probes_create_wildcard_events(struct wildcard_entry *entry,
+				struct session_wildcard *wildcard)
 {
-	struct ltt_event *ev, *tmp;
+	struct lttng_probe_desc *probe_desc;
+	struct lttng_ust_event event_param;
+	int i;
 
-	/*
-	 * Just remove the events owned (for enable/disable) by this
-	 * loglevel from the list. The session teardown will take care
-	 * of freeing the event memory.
-	 */
-	cds_list_for_each_entry_safe(ev, tmp, &loglevel->events, list) {
-		cds_list_del(&ev->list);
-	}
-	cds_list_del(&loglevel->session_list);
-	cds_list_del(&loglevel->list);
-	if (cds_list_empty(&loglevel->entry->session_list)) {
-		cds_hlist_del(&loglevel->entry->hlist);
-		free(loglevel->entry);
-	}
-	free(loglevel);
-}
+	cds_list_for_each_entry(probe_desc, &probe_list, head) {
+		for (i = 0; i < probe_desc->nr_events; i++) {
+			const struct lttng_event_desc *event_desc;
+			int match = 0;
+
+			event_desc = probe_desc->event_desc[i];
+			/* compare excluding final '*' */
+			assert(strlen(entry->name) > 0);
+			if (strcmp(event_desc->name, "lttng_ust:metadata")
+					&& (strlen(entry->name) == 1
+						|| !strncmp(event_desc->name, entry->name,
+							strlen(entry->name) - 1))) {
+				if (ltt_loglevel_match(event_desc,
+					entry->loglevel_type,
+						entry->loglevel)) {
+					match = 1;
+				}
+			}
+			if (match) {
+				struct ltt_event *ev;
+				int ret;
 
-int ltt_loglevel_enable(struct session_loglevel *loglevel)
-{
-	struct ltt_event *ev;
-	int ret;
-
-	if (loglevel->enabled)
-		return -EEXIST;
-	cds_list_for_each_entry(ev, &loglevel->events, list) {
-		ret = ltt_event_enable(ev);
-		if (ret) {
-			DBG("Error: enable error.\n");
-			return ret;
+				memcpy(&event_param, &wildcard->event_param,
+						sizeof(event_param));
+				memcpy(event_param.name,
+					event_desc->name,
+					sizeof(event_param.name));
+				/* create event */
+				ret = ltt_event_create(wildcard->chan,
+					&event_param, &ev);
+				if (ret) {
+					DBG("Error creating event");
+					continue;
+				}
+				cds_list_add(&ev->wildcard_list,
+					&wildcard->events);
+			}
 		}
 	}
-	loglevel->enabled = 1;
-	return 0;
+	lttng_filter_wildcard_link_bytecode(wildcard);
 }
 
-int ltt_loglevel_disable(struct session_loglevel *loglevel)
-{
-	struct ltt_event *ev;
-	int ret;
-
-	if (!loglevel->enabled)
-		return -EEXIST;
-	cds_list_for_each_entry(ev, &loglevel->events, list) {
-		ret = ltt_event_disable(ev);
-		if (ret) {
-			DBG("Error: disable error.\n");
-			return ret;
-		}
-	}
-	loglevel->enabled = 0;
-	return 0;
-}