[lttng-ust.git] / liblttng-ust / ltt-probes.c

/*
 * ltt-probes.c
 *
 * 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.
 *
 * 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>
#include <errno.h>
#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"
#include "error.h"

/*
 * probe list is protected by ust_lock()/ust_unlock().
 */
static CDS_LIST_HEAD(probe_list);

static
const struct lttng_probe_desc *find_provider(const char *provider)
{
	struct lttng_probe_desc *iter;

	cds_list_for_each_entry(iter, &probe_list, head) {
		if (!strcmp(iter->provider, provider))
			return iter;
	}
	return NULL;
}

static
const struct lttng_event_desc *find_event(const char *name)
{
	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];
		}
	}
	return NULL;
}

int ltt_probe_register(struct lttng_probe_desc *desc)
{
	struct lttng_probe_desc *iter;
	int ret = 0;
	int i;

	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.
	 */
	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
	 * 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) {
			/* We belong to the location right after iter. */
			cds_list_add(&desc->head, &iter->head);
			goto desc_added;
		}
	}
	/* 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++) {
		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:
	ust_unlock();
	return ret;
}

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();
}

/*
 * called with UST lock held.
 */
const struct lttng_event_desc *ltt_event_get(const char *name)
{
	const struct lttng_event_desc *event;

	event = find_event(name);
	if (!event)
		return NULL;
	return event;
}

void ltt_event_put(const struct lttng_event_desc *event)
{
}

void ltt_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
{
	struct tp_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);
	}
}

/*
 * called with UST lock held.
 */
int ltt_probes_get_event_list(struct lttng_ust_tracepoint_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++) {
			struct tp_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->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) {
				list_entry->tp.loglevel = TRACE_DEFAULT;
			} else {
				list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel);
			}
		}
	}
	if (cds_list_empty(&list->head))
		list->iter = NULL;
	else
		list->iter =
			cds_list_first_entry(&list->head, struct tp_list_entry, head);
	return 0;

err_nomem:
	ltt_probes_prune_event_list(list);
	return -ENOMEM;
}

/*
 * Return current iteration position, advance internal iterator to next.
 * Return NULL if end of list.
 */
struct lttng_ust_tracepoint_iter *
	lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
{
	struct tp_list_entry *entry;

	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_list_entry, head);
	return &entry->tp;
}

void ltt_probes_prune_field_list(struct lttng_ust_field_list *list)
{
	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);
	}
}

/*
 * called with UST lock held.
 */
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 lttng_event_desc *event_desc =
				probe_desc->event_desc[i];
			int j;

			if (event_desc->nr_fields == 0) {
				/* Events without fields. */
				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';
				list_entry->field.field_name[0] = '\0';
				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);
				}
				list_entry->field.nowrite = 1;
			}

			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);
				}
				list_entry->field.nowrite = event_field->nowrite;
			}
		}
	}
	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;
}

/*
 * Return current iteration position, advance internal iterator to next.
 * Return NULL if end of list.
 */
struct lttng_ust_field_iter *
	lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
{
	struct tp_field_list_entry *entry;

	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;
}

/*
 * marshall all probes/all events and create those that fit the
 * wildcard. Add them to the events list as created.
 */
void ltt_probes_create_wildcard_events(struct wildcard_entry *entry,
				struct session_wildcard *wildcard)
{
	struct lttng_probe_desc *probe_desc;
	struct lttng_ust_event event_param;
	int i;

	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;

				memcpy(&event_param, &wildcard->event_param,
						sizeof(event_param));
				strncpy(event_param.name,
					event_desc->name,
					sizeof(event_param.name));
				event_param.name[sizeof(event_param.name) - 1] = '\0';
				/* 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);
			}
		}
	}
	lttng_filter_wildcard_link_bytecode(wildcard);
}
Commit	Line	Data
ce5aef0b MD	1	/*
	2	* ltt-probes.c
	3	*
ce5aef0b MD	4	* Holds LTTng probes registry.
ce5aef0b MD	5	*
e92f3e28 MD	6	* Copyright 2010-2012 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; only
	11	* version 2.1 of the License.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
ce5aef0b MD	21	*/
ce5aef0b MD	22
8d8a24c8 MD	23	#include <string.h>
	24	#include <errno.h>
	25	#include <urcu/list.h>
1f18504e	26	#include <urcu/hlist.h>
4318ae1b	27	#include <lttng/ust-events.h>
902e1379	28	#include <lttng/tracepoint.h>
d8de1354	29	#include "tracepoint-internal.h"
a3bb4b27	30	#include <assert.h>
c8fcf224	31	#include <helper.h>
48740cab	32	#include <ctype.h>
ce5aef0b	33
8165c8da	34	#include "ltt-tracer-core.h"
1f18504e MD	35	#include "jhash.h"
1f18504e MD	36	#include "error.h"
8165c8da MD	37
8165c8da MD	38	/*
17dfb34b	39	* probe list is protected by ust_lock()/ust_unlock().
8165c8da	40	*/
8d8a24c8	41	static CDS_LIST_HEAD(probe_list);
ce5aef0b	42
df854e41 MD	43	static
	44	const struct lttng_probe_desc find_provider(const char provider)
	45	{
	46	struct lttng_probe_desc *iter;
	47
	48	cds_list_for_each_entry(iter, &probe_list, head) {
	49	if (!strcmp(iter->provider, provider))
	50	return iter;
	51	}
	52	return NULL;
	53	}
	54
ce5aef0b MD	55	static
	56	const struct lttng_event_desc find_event(const char name)
	57	{
	58	struct lttng_probe_desc *probe_desc;
	59	int i;
	60
8d8a24c8	61	cds_list_for_each_entry(probe_desc, &probe_list, head) {
ce5aef0b	62	for (i = 0; i < probe_desc->nr_events; i++) {
ff412fb5 MD	63	if (!strncmp(probe_desc->event_desc[i]->name, name,
ff412fb5 MD	64	LTTNG_UST_SYM_NAME_LEN - 1))
df854e41	65	return probe_desc->event_desc[i];
ce5aef0b MD	66	}
	67	}
	68	return NULL;
	69	}
	70
	71	int ltt_probe_register(struct lttng_probe_desc *desc)
	72	{
df854e41	73	struct lttng_probe_desc *iter;
ce5aef0b MD	74	int ret = 0;
	75	int i;
	76
17dfb34b	77	ust_lock();
df854e41 MD	78	if (find_provider(desc->provider)) {
	79	ret = -EEXIST;
	80	goto end;
	81	}
ce5aef0b MD	82	/*
	83	* TODO: This is O(N^2). Turn into a hash table when probe registration
	84	* overhead becomes an issue.
	85	*/
	86	for (i = 0; i < desc->nr_events; i++) {
df854e41	87	if (find_event(desc->event_desc[i]->name)) {
ce5aef0b MD	88	ret = -EEXIST;
	89	goto end;
	90	}
	91	}
df854e41 MD	92
	93	/*
	94	* We sort the providers by struct lttng_probe_desc pointer
	95	* address.
	96	*/
	97	cds_list_for_each_entry_reverse(iter, &probe_list, head) {
	98	BUG_ON(iter == desc); /* Should never be in the list twice */
	99	if (iter < desc) {
	100	/* We belong to the location right after iter. */
	101	cds_list_add(&desc->head, &iter->head);
	102	goto desc_added;
	103	}
	104	}
	105	/* We should be added at the head of the list */
8d8a24c8	106	cds_list_add(&desc->head, &probe_list);
df854e41	107	desc_added:
e81a53af MD	108	DBG("just registered probe %s containing %u events",
e81a53af MD	109	desc->provider, desc->nr_events);
8165c8da MD	110	/*
	111	* fix the events awaiting probe load.
	112	*/
	113	for (i = 0; i < desc->nr_events; i++) {
68755429 MD	114	const struct lttng_event_desc *ed;
	115
	116	ed = desc->event_desc[i];
	117	DBG("Registered event probe \"%s\" with signature \"%s\"",
	118	ed->name, ed->signature);
	119	ret = pending_probe_fix_events(ed);
8165c8da MD	120	assert(!ret);
8165c8da MD	121	}
ce5aef0b	122	end:
17dfb34b	123	ust_unlock();
ce5aef0b MD	124	return ret;
ce5aef0b MD	125	}
ce5aef0b MD	126
	127	void ltt_probe_unregister(struct lttng_probe_desc *desc)
	128	{
17dfb34b	129	ust_lock();
8d8a24c8	130	cds_list_del(&desc->head);
e81a53af	131	DBG("just unregistered probe %s", desc->provider);
17dfb34b	132	ust_unlock();
ce5aef0b	133	}
ce5aef0b	134
8165c8da MD	135	/*
	136	* called with UST lock held.
	137	*/
ce5aef0b MD	138	const struct lttng_event_desc ltt_event_get(const char name)
	139	{
	140	const struct lttng_event_desc *event;
ce5aef0b	141
ce5aef0b	142	event = find_event(name);
ce5aef0b MD	143	if (!event)
ce5aef0b MD	144	return NULL;
ce5aef0b MD	145	return event;
ce5aef0b MD	146	}
ce5aef0b MD	147
	148	void ltt_event_put(const struct lttng_event_desc *event)
	149	{
ce5aef0b	150	}
c8fcf224 MD	151
	152	void ltt_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
	153	{
	154	struct tp_list_entry list_entry, tmp;
	155
	156	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
	157	cds_list_del(&list_entry->head);
	158	free(list_entry);
	159	}
	160	}
	161
	162	/*
	163	* called with UST lock held.
	164	*/
	165	int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
	166	{
	167	struct lttng_probe_desc *probe_desc;
	168	int i;
	169
	170	CDS_INIT_LIST_HEAD(&list->head);
	171	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	172	for (i = 0; i < probe_desc->nr_events; i++) {
	173	struct tp_list_entry *list_entry;
	174
	175	list_entry = zmalloc(sizeof(*list_entry));
	176	if (!list_entry)
	177	goto err_nomem;
	178	cds_list_add(&list_entry->head, &list->head);
	179	strncpy(list_entry->tp.name,
	180	probe_desc->event_desc[i]->name,
	181	LTTNG_UST_SYM_NAME_LEN);
	182	list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	183	if (!probe_desc->event_desc[i]->loglevel) {
882a56d7	184	list_entry->tp.loglevel = TRACE_DEFAULT;
c8fcf224	185	} else {
882a56d7	186	list_entry->tp.loglevel = (probe_desc->event_desc[i]->loglevel);
c8fcf224 MD	187	}
	188	}
	189	}
	190	if (cds_list_empty(&list->head))
	191	list->iter = NULL;
	192	else
	193	list->iter =
	194	cds_list_first_entry(&list->head, struct tp_list_entry, head);
	195	return 0;
	196
	197	err_nomem:
	198	ltt_probes_prune_event_list(list);
	199	return -ENOMEM;
	200	}
	201
	202	/*
	203	* Return current iteration position, advance internal iterator to next.
	204	* Return NULL if end of list.
	205	*/
	206	struct lttng_ust_tracepoint_iter *
	207	lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
	208	{
	209	struct tp_list_entry *entry;
	210
	211	if (!list->iter)
	212	return NULL;
	213	entry = list->iter;
	214	if (entry->head.next == &list->head)
	215	list->iter = NULL;
	216	else
	217	list->iter = cds_list_entry(entry->head.next,
	218	struct tp_list_entry, head);
	219	return &entry->tp;
	220	}
1f18504e	221
06d4f27e MD	222	void ltt_probes_prune_field_list(struct lttng_ust_field_list *list)
	223	{
	224	struct tp_field_list_entry list_entry, tmp;
	225
	226	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
	227	cds_list_del(&list_entry->head);
	228	free(list_entry);
	229	}
	230	}
	231
	232	/*
	233	* called with UST lock held.
	234	*/
	235	int ltt_probes_get_field_list(struct lttng_ust_field_list *list)
	236	{
	237	struct lttng_probe_desc *probe_desc;
	238	int i;
	239
	240	CDS_INIT_LIST_HEAD(&list->head);
	241	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	242	for (i = 0; i < probe_desc->nr_events; i++) {
	243	const struct lttng_event_desc *event_desc =
	244	probe_desc->event_desc[i];
	245	int j;
	246
26329f26 MD	247	if (event_desc->nr_fields == 0) {
	248	/* Events without fields. */
	249	struct tp_field_list_entry *list_entry;
	250
	251	list_entry = zmalloc(sizeof(*list_entry));
	252	if (!list_entry)
	253	goto err_nomem;
	254	cds_list_add(&list_entry->head, &list->head);
	255	strncpy(list_entry->field.event_name,
	256	event_desc->name,
	257	LTTNG_UST_SYM_NAME_LEN);
	258	list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	259	list_entry->field.field_name[0] = '\0';
	260	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	261	if (!event_desc->loglevel) {
	262	list_entry->field.loglevel = TRACE_DEFAULT;
	263	} else {
	264	list_entry->field.loglevel = (event_desc->loglevel);
	265	}
	266	list_entry->field.nowrite = 1;
	267	}
	268
06d4f27e MD	269	for (j = 0; j < event_desc->nr_fields; j++) {
	270	const struct lttng_event_field *event_field =
	271	&event_desc->fields[j];
	272	struct tp_field_list_entry *list_entry;
	273
	274	list_entry = zmalloc(sizeof(*list_entry));
	275	if (!list_entry)
	276	goto err_nomem;
	277	cds_list_add(&list_entry->head, &list->head);
	278	strncpy(list_entry->field.event_name,
	279	event_desc->name,
	280	LTTNG_UST_SYM_NAME_LEN);
	281	list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	282	strncpy(list_entry->field.field_name,
	283	event_field->name,
	284	LTTNG_UST_SYM_NAME_LEN);
	285	list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
40003310 MD	286	switch (event_field->type.atype) {
	287	case atype_integer:
	288	list_entry->field.type = LTTNG_UST_FIELD_INTEGER;
	289	break;
	290	case atype_string:
	291	list_entry->field.type = LTTNG_UST_FIELD_STRING;
	292	break;
	293	case atype_array:
	294	if (event_field->type.u.array.elem_type.atype != atype_integer
	295	\|\| event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none)
	296	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	297	else
	298	list_entry->field.type = LTTNG_UST_FIELD_STRING;
	299	break;
	300	case atype_sequence:
	301	if (event_field->type.u.sequence.elem_type.atype != atype_integer
	302	\|\| event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none)
	303	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	304	else
	305	list_entry->field.type = LTTNG_UST_FIELD_STRING;
	306	break;
	307	case atype_float:
	308	list_entry->field.type = LTTNG_UST_FIELD_FLOAT;
	309	break;
	310	case atype_enum:
	311	list_entry->field.type = LTTNG_UST_FIELD_ENUM;
	312	break;
	313	default:
	314	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	315	}
06d4f27e MD	316	if (!event_desc->loglevel) {
	317	list_entry->field.loglevel = TRACE_DEFAULT;
	318	} else {
	319	list_entry->field.loglevel = (event_desc->loglevel);
	320	}
180901e6	321	list_entry->field.nowrite = event_field->nowrite;
06d4f27e MD	322	}
	323	}
	324	}
	325	if (cds_list_empty(&list->head))
	326	list->iter = NULL;
	327	else
	328	list->iter =
	329	cds_list_first_entry(&list->head,
	330	struct tp_field_list_entry, head);
	331	return 0;
	332
	333	err_nomem:
	334	ltt_probes_prune_field_list(list);
	335	return -ENOMEM;
	336	}
	337
	338	/*
	339	* Return current iteration position, advance internal iterator to next.
	340	* Return NULL if end of list.
	341	*/
	342	struct lttng_ust_field_iter *
	343	lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
	344	{
	345	struct tp_field_list_entry *entry;
	346
	347	if (!list->iter)
	348	return NULL;
	349	entry = list->iter;
	350	if (entry->head.next == &list->head)
	351	list->iter = NULL;
	352	else
	353	list->iter = cds_list_entry(entry->head.next,
	354	struct tp_field_list_entry, head);
	355	return &entry->field;
	356	}
	357
e6c12e3d MD	358	/*
	359	* marshall all probes/all events and create those that fit the
	360	* wildcard. Add them to the events list as created.
	361	*/
457a6b58	362	void ltt_probes_create_wildcard_events(struct wildcard_entry *entry,
e6c12e3d MD	363	struct session_wildcard *wildcard)
	364	{
	365	struct lttng_probe_desc *probe_desc;
	366	struct lttng_ust_event event_param;
	367	int i;
	368
	369	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	370	for (i = 0; i < probe_desc->nr_events; i++) {
	371	const struct lttng_event_desc *event_desc;
	372	int match = 0;
	373
	374	event_desc = probe_desc->event_desc[i];
	375	/* compare excluding final '' /
	376	assert(strlen(entry->name) > 0);
	377	if (strcmp(event_desc->name, "lttng_ust:metadata")
	378	&& (strlen(entry->name) == 1
	379	\|\| !strncmp(event_desc->name, entry->name,
	380	strlen(entry->name) - 1))) {
457a6b58 MD	381	if (ltt_loglevel_match(event_desc,
	382	entry->loglevel_type,
	383	entry->loglevel)) {
	384	match = 1;
	385	}
e6c12e3d MD	386	}
	387	if (match) {
	388	struct ltt_event *ev;
	389	int ret;
	390
	391	memcpy(&event_param, &wildcard->event_param,
	392	sizeof(event_param));
1c7b4a9b	393	strncpy(event_param.name,
e6c12e3d MD	394	event_desc->name,
e6c12e3d MD	395	sizeof(event_param.name));
1c7b4a9b	396	event_param.name[sizeof(event_param.name) - 1] = '\0';
e6c12e3d MD	397	/* create event */
e6c12e3d MD	398	ret = ltt_event_create(wildcard->chan,
2d78951a	399	&event_param, &ev);
e6c12e3d MD	400	if (ret) {
	401	DBG("Error creating event");
	402	continue;
	403	}
	404	cds_list_add(&ev->wildcard_list,
	405	&wildcard->events);
	406	}
	407	}
	408	}
2d78951a	409	lttng_filter_wildcard_link_bytecode(wildcard);
e6c12e3d MD	410	}
e6c12e3d MD	411