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

/*
 * lttng-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 "lttng-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 lttng_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;
}

/* Backward compatibility with UST 2.0 */
int ltt_probe_register(struct lttng_probe_desc *desc)
{
	return lttng_probe_register(desc);
}

void lttng_probe_unregister(struct lttng_probe_desc *desc)
{
	ust_lock();
	cds_list_del(&desc->head);
	DBG("just unregistered probe %s", desc->provider);
	ust_unlock();
}

/* Backward compatibility with UST 2.0 */
void ltt_probe_unregister(struct lttng_probe_desc *desc)
{
	lttng_probe_unregister(desc);
}

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

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

void lttng_event_put(const struct lttng_event_desc *event)
{
}

void lttng_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 lttng_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:
	lttng_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 lttng_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 lttng_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:
	lttng_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 lttng_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 (lttng_loglevel_match(event_desc,
					entry->loglevel_type,
						entry->loglevel)) {
					match = 1;
				}
			}
			if (match) {
				struct lttng_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 = lttng_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	1	/*
7dd08bec	2	* lttng-probes.c
ce5aef0b	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
7dd08bec	34	#include "lttng-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
7dd08bec	71	int lttng_probe_register(struct lttng_probe_desc *desc)
ce5aef0b	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	126
7dd08bec MD	127	/* Backward compatibility with UST 2.0 */
	128	int ltt_probe_register(struct lttng_probe_desc *desc)
	129	{
	130	return lttng_probe_register(desc);
	131	}
	132
	133	void lttng_probe_unregister(struct lttng_probe_desc *desc)
ce5aef0b	134	{
17dfb34b	135	ust_lock();
8d8a24c8	136	cds_list_del(&desc->head);
e81a53af	137	DBG("just unregistered probe %s", desc->provider);
17dfb34b	138	ust_unlock();
ce5aef0b	139	}
ce5aef0b	140
7dd08bec MD	141	/* Backward compatibility with UST 2.0 */
	142	void ltt_probe_unregister(struct lttng_probe_desc *desc)
	143	{
	144	lttng_probe_unregister(desc);
	145	}
	146
8165c8da MD	147	/*
	148	* called with UST lock held.
	149	*/
7dd08bec	150	const struct lttng_event_desc lttng_event_get(const char name)
ce5aef0b MD	151	{
ce5aef0b MD	152	const struct lttng_event_desc *event;
ce5aef0b	153
ce5aef0b	154	event = find_event(name);
ce5aef0b MD	155	if (!event)
ce5aef0b MD	156	return NULL;
ce5aef0b MD	157	return event;
ce5aef0b MD	158	}
ce5aef0b	159
7dd08bec	160	void lttng_event_put(const struct lttng_event_desc *event)
ce5aef0b	161	{
ce5aef0b	162	}
c8fcf224	163
7dd08bec	164	void lttng_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
c8fcf224 MD	165	{
	166	struct tp_list_entry list_entry, tmp;
	167
	168	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
	169	cds_list_del(&list_entry->head);
	170	free(list_entry);
	171	}
	172	}
	173
	174	/*
	175	* called with UST lock held.
	176	*/
7dd08bec	177	int lttng_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
c8fcf224 MD	178	{
	179	struct lttng_probe_desc *probe_desc;
	180	int i;
	181
	182	CDS_INIT_LIST_HEAD(&list->head);
	183	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	184	for (i = 0; i < probe_desc->nr_events; i++) {
	185	struct tp_list_entry *list_entry;
	186
	187	list_entry = zmalloc(sizeof(*list_entry));
	188	if (!list_entry)
	189	goto err_nomem;
	190	cds_list_add(&list_entry->head, &list->head);
	191	strncpy(list_entry->tp.name,
	192	probe_desc->event_desc[i]->name,
	193	LTTNG_UST_SYM_NAME_LEN);
	194	list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	195	if (!probe_desc->event_desc[i]->loglevel) {
882a56d7	196	list_entry->tp.loglevel = TRACE_DEFAULT;
c8fcf224	197	} else {
882a56d7	198	list_entry->tp.loglevel = (probe_desc->event_desc[i]->loglevel);
c8fcf224 MD	199	}
	200	}
	201	}
	202	if (cds_list_empty(&list->head))
	203	list->iter = NULL;
	204	else
	205	list->iter =
	206	cds_list_first_entry(&list->head, struct tp_list_entry, head);
	207	return 0;
	208
	209	err_nomem:
7dd08bec	210	lttng_probes_prune_event_list(list);
c8fcf224 MD	211	return -ENOMEM;
	212	}
	213
	214	/*
	215	* Return current iteration position, advance internal iterator to next.
	216	* Return NULL if end of list.
	217	*/
	218	struct lttng_ust_tracepoint_iter *
	219	lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
	220	{
	221	struct tp_list_entry *entry;
	222
	223	if (!list->iter)
	224	return NULL;
	225	entry = list->iter;
	226	if (entry->head.next == &list->head)
	227	list->iter = NULL;
	228	else
	229	list->iter = cds_list_entry(entry->head.next,
	230	struct tp_list_entry, head);
	231	return &entry->tp;
	232	}
1f18504e	233
7dd08bec	234	void lttng_probes_prune_field_list(struct lttng_ust_field_list *list)
06d4f27e MD	235	{
	236	struct tp_field_list_entry list_entry, tmp;
	237
	238	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
	239	cds_list_del(&list_entry->head);
	240	free(list_entry);
	241	}
	242	}
	243
	244	/*
	245	* called with UST lock held.
	246	*/
7dd08bec	247	int lttng_probes_get_field_list(struct lttng_ust_field_list *list)
06d4f27e MD	248	{
	249	struct lttng_probe_desc *probe_desc;
	250	int i;
	251
	252	CDS_INIT_LIST_HEAD(&list->head);
	253	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	254	for (i = 0; i < probe_desc->nr_events; i++) {
	255	const struct lttng_event_desc *event_desc =
	256	probe_desc->event_desc[i];
	257	int j;
	258
26329f26 MD	259	if (event_desc->nr_fields == 0) {
	260	/* Events without fields. */
	261	struct tp_field_list_entry *list_entry;
	262
	263	list_entry = zmalloc(sizeof(*list_entry));
	264	if (!list_entry)
	265	goto err_nomem;
	266	cds_list_add(&list_entry->head, &list->head);
	267	strncpy(list_entry->field.event_name,
	268	event_desc->name,
	269	LTTNG_UST_SYM_NAME_LEN);
	270	list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	271	list_entry->field.field_name[0] = '\0';
	272	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	273	if (!event_desc->loglevel) {
	274	list_entry->field.loglevel = TRACE_DEFAULT;
	275	} else {
	276	list_entry->field.loglevel = (event_desc->loglevel);
	277	}
	278	list_entry->field.nowrite = 1;
	279	}
	280
06d4f27e MD	281	for (j = 0; j < event_desc->nr_fields; j++) {
	282	const struct lttng_event_field *event_field =
	283	&event_desc->fields[j];
	284	struct tp_field_list_entry *list_entry;
	285
	286	list_entry = zmalloc(sizeof(*list_entry));
	287	if (!list_entry)
	288	goto err_nomem;
	289	cds_list_add(&list_entry->head, &list->head);
	290	strncpy(list_entry->field.event_name,
	291	event_desc->name,
	292	LTTNG_UST_SYM_NAME_LEN);
	293	list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	294	strncpy(list_entry->field.field_name,
	295	event_field->name,
	296	LTTNG_UST_SYM_NAME_LEN);
	297	list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
40003310 MD	298	switch (event_field->type.atype) {
	299	case atype_integer:
	300	list_entry->field.type = LTTNG_UST_FIELD_INTEGER;
	301	break;
	302	case atype_string:
	303	list_entry->field.type = LTTNG_UST_FIELD_STRING;
	304	break;
	305	case atype_array:
	306	if (event_field->type.u.array.elem_type.atype != atype_integer
	307	\|\| event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none)
	308	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	309	else
	310	list_entry->field.type = LTTNG_UST_FIELD_STRING;
	311	break;
	312	case atype_sequence:
	313	if (event_field->type.u.sequence.elem_type.atype != atype_integer
	314	\|\| event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none)
	315	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	316	else
	317	list_entry->field.type = LTTNG_UST_FIELD_STRING;
	318	break;
	319	case atype_float:
	320	list_entry->field.type = LTTNG_UST_FIELD_FLOAT;
	321	break;
	322	case atype_enum:
	323	list_entry->field.type = LTTNG_UST_FIELD_ENUM;
	324	break;
	325	default:
	326	list_entry->field.type = LTTNG_UST_FIELD_OTHER;
	327	}
06d4f27e MD	328	if (!event_desc->loglevel) {
	329	list_entry->field.loglevel = TRACE_DEFAULT;
	330	} else {
	331	list_entry->field.loglevel = (event_desc->loglevel);
	332	}
180901e6	333	list_entry->field.nowrite = event_field->nowrite;
06d4f27e MD	334	}
	335	}
	336	}
	337	if (cds_list_empty(&list->head))
	338	list->iter = NULL;
	339	else
	340	list->iter =
	341	cds_list_first_entry(&list->head,
	342	struct tp_field_list_entry, head);
	343	return 0;
	344
	345	err_nomem:
7dd08bec	346	lttng_probes_prune_field_list(list);
06d4f27e MD	347	return -ENOMEM;
	348	}
	349
	350	/*
	351	* Return current iteration position, advance internal iterator to next.
	352	* Return NULL if end of list.
	353	*/
	354	struct lttng_ust_field_iter *
	355	lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
	356	{
	357	struct tp_field_list_entry *entry;
	358
	359	if (!list->iter)
	360	return NULL;
	361	entry = list->iter;
	362	if (entry->head.next == &list->head)
	363	list->iter = NULL;
	364	else
	365	list->iter = cds_list_entry(entry->head.next,
	366	struct tp_field_list_entry, head);
	367	return &entry->field;
	368	}
	369
e6c12e3d MD	370	/*
	371	* marshall all probes/all events and create those that fit the
	372	* wildcard. Add them to the events list as created.
	373	*/
7dd08bec	374	void lttng_probes_create_wildcard_events(struct wildcard_entry *entry,
e6c12e3d MD	375	struct session_wildcard *wildcard)
	376	{
	377	struct lttng_probe_desc *probe_desc;
	378	struct lttng_ust_event event_param;
	379	int i;
	380
	381	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	382	for (i = 0; i < probe_desc->nr_events; i++) {
	383	const struct lttng_event_desc *event_desc;
	384	int match = 0;
	385
	386	event_desc = probe_desc->event_desc[i];
	387	/* compare excluding final '' /
	388	assert(strlen(entry->name) > 0);
	389	if (strcmp(event_desc->name, "lttng_ust:metadata")
	390	&& (strlen(entry->name) == 1
	391	\|\| !strncmp(event_desc->name, entry->name,
	392	strlen(entry->name) - 1))) {
7dd08bec	393	if (lttng_loglevel_match(event_desc,
457a6b58 MD	394	entry->loglevel_type,
	395	entry->loglevel)) {
	396	match = 1;
	397	}
e6c12e3d MD	398	}
e6c12e3d MD	399	if (match) {
7dd08bec	400	struct lttng_event *ev;
e6c12e3d MD	401	int ret;
	402
	403	memcpy(&event_param, &wildcard->event_param,
	404	sizeof(event_param));
1c7b4a9b	405	strncpy(event_param.name,
e6c12e3d MD	406	event_desc->name,
e6c12e3d MD	407	sizeof(event_param.name));
1c7b4a9b	408	event_param.name[sizeof(event_param.name) - 1] = '\0';
e6c12e3d	409	/* create event */
7dd08bec	410	ret = lttng_event_create(wildcard->chan,
2d78951a	411	&event_param, &ev);
e6c12e3d MD	412	if (ret) {
	413	DBG("Error creating event");
	414	continue;
	415	}
	416	cds_list_add(&ev->wildcard_list,
	417	&wildcard->events);
	418	}
	419	}
	420	}
2d78951a	421	lttng_filter_wildcard_link_bytecode(wildcard);
e6c12e3d MD	422	}
e6c12e3d MD	423