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

/*
 * ltt-probes.c
 *
 * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Holds LTTng probes registry.
 *
 * Dual LGPL v2.1/GPL v2 license.
 */

#include <string.h>
#include <errno.h>
#include <urcu/list.h>
#include <urcu/hlist.h>
#include <lttng/ust-events.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);

/*
 * Wildcard list, containing the active wildcards.
 * Protected by ust lock.
 */
static CDS_LIST_HEAD(wildcard_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++) {
		ret = pending_probe_fix_events(desc->event_desc[i]);
		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[0] = '\0';
				list_entry->tp.loglevel_value = 0;
			} 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;
			}
		}
	}
	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;
}

/* WILDCARDS */

/*
 * Return wildcard for a given event name if the event name match the
 * one of the wildcards.
 * Must be called with ust lock held.
 * Returns NULL if not present.
 */
struct wildcard_entry *match_wildcard(const char *name)
{
	struct wildcard_entry *e;

	cds_list_for_each_entry(e, &wildcard_list, list) {
		/* If only contain '*' */
		if (strlen(e->name) == 1)
			return e;
		/* Compare excluding final '*' */
		if (!strncmp(name, e->name, strlen(e->name) - 1))
			return e;
	}
	return NULL;
}

/*
 * marshall all probes/all events and create those that fit the
 * wildcard. Add them to the events list as created.
 */
static
void _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))) {
				/* TODO: get value from loglevel. */

				/* TODO: check if loglevel match */
				//if (event_desc->loglevel
				//	&& (*event_desc->loglevel)->value ...)
				match = 1;
			}
			if (match) {
				struct ltt_event *ev;
				int 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, NULL,
					&ev);
				if (ret) {
					DBG("Error creating event");
					continue;
				}
				cds_list_add(&ev->wildcard_list,
					&wildcard->events);
			}
		}
	}
}

/*
 * Add the wildcard to the wildcard list. Must be called with
 * ust lock held.
 */
struct session_wildcard *add_wildcard(const char *name,
	struct ltt_channel *chan,
	struct lttng_ust_event *event_param)
{
	struct wildcard_entry *e;
	struct session_wildcard *sw;
	size_t name_len = strlen(name) + 1;
	int found = 0;

	/* try to find global wildcard entry */
	cds_list_for_each_entry(e, &wildcard_list, list) {
		if (!strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1)) {
			found = 1;
			break;
		}
	}

	if (!found) {
		/*
		 * Create global wildcard entry if not found. Using
		 * zmalloc here to allocate a variable length element.
		 * Could cause some memory fragmentation if overused.
		 */
		e = zmalloc(sizeof(struct wildcard_entry) + name_len);
		if (!e)
			return ERR_PTR(-ENOMEM);
		memcpy(&e->name[0], name, name_len);
		cds_list_add(&e->list, &wildcard_list);
		CDS_INIT_LIST_HEAD(&e->session_list);
	}

	/* session wildcard */
	cds_list_for_each_entry(sw, &e->session_list, session_list) {
		if (chan == sw->chan) {
			DBG("wildcard %s busy for this channel", name);
			return ERR_PTR(-EEXIST);	/* Already there */
		}
	}
	sw = zmalloc(sizeof(struct session_wildcard));
	if (!sw)
		return ERR_PTR(-ENOMEM);
	sw->chan = chan;
	sw->enabled = 1;
	memcpy(&sw->event_param, event_param, sizeof(sw->event_param));
	sw->event_param.instrumentation = LTTNG_UST_TRACEPOINT;
	CDS_INIT_LIST_HEAD(&sw->events);
	cds_list_add(&sw->list, &chan->session->wildcards);
	cds_list_add(&sw->session_list, &e->session_list);
	sw->entry = e;
	_probes_create_wildcard_events(e, sw);
	return sw;
}

/*
 * Remove the wildcard from the wildcard list. Must be called with
 * ust_lock held. Only called at session teardown.
 */
void _remove_wildcard(struct session_wildcard *wildcard)
{
	struct ltt_event *ev, *tmp;

	/*
	 * Just remove the events owned (for enable/disable) by this
	 * wildcard from the list. The session teardown will take care
	 * of freeing the event memory.
	 */
	cds_list_for_each_entry_safe(ev, tmp, &wildcard->events,
			wildcard_list) {
		cds_list_del(&ev->wildcard_list);
	}
	cds_list_del(&wildcard->session_list);
	cds_list_del(&wildcard->list);
	if (cds_list_empty(&wildcard->entry->session_list)) {
		cds_list_del(&wildcard->entry->list);
		free(wildcard->entry);
	}
	free(wildcard);
}

int ltt_wildcard_enable(struct session_wildcard *wildcard)
{
	struct ltt_event *ev;
	int ret;

	if (wildcard->enabled)
		return -EEXIST;
	cds_list_for_each_entry(ev, &wildcard->events, wildcard_list) {
		ret = ltt_event_enable(ev);
		if (ret) {
			DBG("Error: enable error.\n");
			return ret;
		}
	}
	wildcard->enabled = 1;
	return 0;
}

int ltt_wildcard_disable(struct session_wildcard *wildcard)
{
	struct ltt_event *ev;
	int ret;

	if (!wildcard->enabled)
		return -EEXIST;
	cds_list_for_each_entry(ev, &wildcard->events, wildcard_list) {
		ret = ltt_event_disable(ev);
		if (ret) {
			DBG("Error: disable error.\n");
			return ret;
		}
	}
	wildcard->enabled = 0;
	return 0;
}
Commit	Line	Data
ce5aef0b MD	1	/*
	2	* ltt-probes.c
	3	*
	4	* Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	5	*
	6	* Holds LTTng probes registry.
	7	*
	8	* Dual LGPL v2.1/GPL v2 license.
	9	*/
	10
8d8a24c8 MD	11	#include <string.h>
	12	#include <errno.h>
	13	#include <urcu/list.h>
1f18504e	14	#include <urcu/hlist.h>
4318ae1b	15	#include <lttng/ust-events.h>
a3bb4b27	16	#include <assert.h>
c8fcf224	17	#include <helper.h>
48740cab	18	#include <ctype.h>
ce5aef0b	19
8165c8da	20	#include "ltt-tracer-core.h"
1f18504e MD	21	#include "jhash.h"
1f18504e MD	22	#include "error.h"
8165c8da MD	23
8165c8da MD	24	/*
17dfb34b	25	* probe list is protected by ust_lock()/ust_unlock().
8165c8da	26	*/
8d8a24c8	27	static CDS_LIST_HEAD(probe_list);
ce5aef0b	28
e6c12e3d MD	29	/*
	30	* Wildcard list, containing the active wildcards.
	31	* Protected by ust lock.
	32	*/
	33	static CDS_LIST_HEAD(wildcard_list);
	34
df854e41 MD	35	static
	36	const struct lttng_probe_desc find_provider(const char provider)
	37	{
	38	struct lttng_probe_desc *iter;
	39
	40	cds_list_for_each_entry(iter, &probe_list, head) {
	41	if (!strcmp(iter->provider, provider))
	42	return iter;
	43	}
	44	return NULL;
	45	}
	46
ce5aef0b MD	47	static
	48	const struct lttng_event_desc find_event(const char name)
	49	{
	50	struct lttng_probe_desc *probe_desc;
	51	int i;
	52
8d8a24c8	53	cds_list_for_each_entry(probe_desc, &probe_list, head) {
ce5aef0b	54	for (i = 0; i < probe_desc->nr_events; i++) {
ff412fb5 MD	55	if (!strncmp(probe_desc->event_desc[i]->name, name,
ff412fb5 MD	56	LTTNG_UST_SYM_NAME_LEN - 1))
df854e41	57	return probe_desc->event_desc[i];
ce5aef0b MD	58	}
	59	}
	60	return NULL;
	61	}
	62
	63	int ltt_probe_register(struct lttng_probe_desc *desc)
	64	{
df854e41	65	struct lttng_probe_desc *iter;
ce5aef0b MD	66	int ret = 0;
	67	int i;
	68
17dfb34b	69	ust_lock();
df854e41 MD	70	if (find_provider(desc->provider)) {
	71	ret = -EEXIST;
	72	goto end;
	73	}
ce5aef0b MD	74	/*
	75	* TODO: This is O(N^2). Turn into a hash table when probe registration
	76	* overhead becomes an issue.
	77	*/
	78	for (i = 0; i < desc->nr_events; i++) {
df854e41	79	if (find_event(desc->event_desc[i]->name)) {
ce5aef0b MD	80	ret = -EEXIST;
	81	goto end;
	82	}
	83	}
df854e41 MD	84
	85	/*
	86	* We sort the providers by struct lttng_probe_desc pointer
	87	* address.
	88	*/
	89	cds_list_for_each_entry_reverse(iter, &probe_list, head) {
	90	BUG_ON(iter == desc); /* Should never be in the list twice */
	91	if (iter < desc) {
	92	/* We belong to the location right after iter. */
	93	cds_list_add(&desc->head, &iter->head);
	94	goto desc_added;
	95	}
	96	}
	97	/* We should be added at the head of the list */
8d8a24c8	98	cds_list_add(&desc->head, &probe_list);
df854e41	99	desc_added:
e81a53af MD	100	DBG("just registered probe %s containing %u events",
e81a53af MD	101	desc->provider, desc->nr_events);
8165c8da MD	102	/*
	103	* fix the events awaiting probe load.
	104	*/
	105	for (i = 0; i < desc->nr_events; i++) {
df854e41	106	ret = pending_probe_fix_events(desc->event_desc[i]);
8165c8da MD	107	assert(!ret);
8165c8da MD	108	}
ce5aef0b	109	end:
17dfb34b	110	ust_unlock();
ce5aef0b MD	111	return ret;
ce5aef0b MD	112	}
ce5aef0b MD	113
	114	void ltt_probe_unregister(struct lttng_probe_desc *desc)
	115	{
17dfb34b	116	ust_lock();
8d8a24c8	117	cds_list_del(&desc->head);
e81a53af	118	DBG("just unregistered probe %s", desc->provider);
17dfb34b	119	ust_unlock();
ce5aef0b	120	}
ce5aef0b	121
8165c8da MD	122	/*
	123	* called with UST lock held.
	124	*/
ce5aef0b MD	125	const struct lttng_event_desc ltt_event_get(const char name)
	126	{
	127	const struct lttng_event_desc *event;
ce5aef0b	128
ce5aef0b	129	event = find_event(name);
ce5aef0b MD	130	if (!event)
ce5aef0b MD	131	return NULL;
ce5aef0b MD	132	return event;
ce5aef0b MD	133	}
ce5aef0b MD	134
	135	void ltt_event_put(const struct lttng_event_desc *event)
	136	{
ce5aef0b	137	}
c8fcf224 MD	138
	139	void ltt_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
	140	{
	141	struct tp_list_entry list_entry, tmp;
	142
	143	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
	144	cds_list_del(&list_entry->head);
	145	free(list_entry);
	146	}
	147	}
	148
	149	/*
	150	* called with UST lock held.
	151	*/
	152	int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
	153	{
	154	struct lttng_probe_desc *probe_desc;
	155	int i;
	156
	157	CDS_INIT_LIST_HEAD(&list->head);
	158	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	159	for (i = 0; i < probe_desc->nr_events; i++) {
	160	struct tp_list_entry *list_entry;
	161
	162	list_entry = zmalloc(sizeof(*list_entry));
	163	if (!list_entry)
	164	goto err_nomem;
	165	cds_list_add(&list_entry->head, &list->head);
	166	strncpy(list_entry->tp.name,
	167	probe_desc->event_desc[i]->name,
	168	LTTNG_UST_SYM_NAME_LEN);
	169	list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	170	if (!probe_desc->event_desc[i]->loglevel) {
	171	list_entry->tp.loglevel[0] = '\0';
	172	list_entry->tp.loglevel_value = 0;
	173	} else {
	174	strncpy(list_entry->tp.loglevel,
	175	(*probe_desc->event_desc[i]->loglevel)->identifier,
	176	LTTNG_UST_SYM_NAME_LEN);
	177	list_entry->tp.loglevel[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	178	list_entry->tp.loglevel_value =
	179	(*probe_desc->event_desc[i]->loglevel)->value;
	180	}
	181	}
	182	}
	183	if (cds_list_empty(&list->head))
	184	list->iter = NULL;
	185	else
	186	list->iter =
	187	cds_list_first_entry(&list->head, struct tp_list_entry, head);
	188	return 0;
	189
	190	err_nomem:
	191	ltt_probes_prune_event_list(list);
	192	return -ENOMEM;
	193	}
	194
	195	/*
	196	* Return current iteration position, advance internal iterator to next.
	197	* Return NULL if end of list.
	198	*/
	199	struct lttng_ust_tracepoint_iter *
	200	lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
	201	{
202	struct tp_list_entry *entry;
203
204	if (!list->iter)
205	return NULL;
206	entry = list->iter;
207	if (entry->head.next == &list->head)
208	list->iter = NULL;
209	else
210	list->iter = cds_list_entry(entry->head.next,
211	struct tp_list_entry, head);
212	return &entry->tp;
213	}
1f18504e	214
e6c12e3d MD	215	/* WILDCARDS */
	216
	217	/*
	218	* Return wildcard for a given event name if the event name match the
	219	* one of the wildcards.
	220	* Must be called with ust lock held.
	221	* Returns NULL if not present.
	222	*/
	223	struct wildcard_entry match_wildcard(const char name)
	224	{
	225	struct wildcard_entry *e;
	226
	227	cds_list_for_each_entry(e, &wildcard_list, list) {
	228	/* If only contain '' /
	229	if (strlen(e->name) == 1)
	230	return e;
	231	/* Compare excluding final '' /
	232	if (!strncmp(name, e->name, strlen(e->name) - 1))
	233	return e;
	234	}
	235	return NULL;
	236	}
	237
	238	/*
	239	* marshall all probes/all events and create those that fit the
	240	* wildcard. Add them to the events list as created.
	241	*/
	242	static
	243	void _probes_create_wildcard_events(struct wildcard_entry *entry,
	244	struct session_wildcard *wildcard)
	245	{
	246	struct lttng_probe_desc *probe_desc;
	247	struct lttng_ust_event event_param;
	248	int i;
	249
	250	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	251	for (i = 0; i < probe_desc->nr_events; i++) {
	252	const struct lttng_event_desc *event_desc;
	253	int match = 0;
	254
	255	event_desc = probe_desc->event_desc[i];
	256	/* compare excluding final '' /
	257	assert(strlen(entry->name) > 0);
	258	if (strcmp(event_desc->name, "lttng_ust:metadata")
	259	&& (strlen(entry->name) == 1
	260	\|\| !strncmp(event_desc->name, entry->name,
	261	strlen(entry->name) - 1))) {
51c5df09 MD	262	/* TODO: get value from loglevel. */
	263
	264	/* TODO: check if loglevel match */
	265	//if (event_desc->loglevel
	266	// && (*event_desc->loglevel)->value ...)
e6c12e3d MD	267	match = 1;
	268	}
	269	if (match) {
	270	struct ltt_event *ev;
	271	int ret;
	272
	273	memcpy(&event_param, &wildcard->event_param,
	274	sizeof(event_param));
	275	memcpy(event_param.name,
	276	event_desc->name,
	277	sizeof(event_param.name));
	278	/* create event */
	279	ret = ltt_event_create(wildcard->chan,
	280	&event_param, NULL,
	281	&ev);
	282	if (ret) {
	283	DBG("Error creating event");
	284	continue;
	285	}
	286	cds_list_add(&ev->wildcard_list,
	287	&wildcard->events);
	288	}
	289	}
	290	}
	291	}
	292
	293	/*
51c5df09	294	* Add the wildcard to the wildcard list. Must be called with
e6c12e3d MD	295	* ust lock held.
	296	*/
	297	struct session_wildcard add_wildcard(const char name,
	298	struct ltt_channel *chan,
	299	struct lttng_ust_event *event_param)
	300	{
	301	struct wildcard_entry *e;
	302	struct session_wildcard *sw;
	303	size_t name_len = strlen(name) + 1;
	304	int found = 0;
	305
51c5df09	306	/* try to find global wildcard entry */
e6c12e3d	307	cds_list_for_each_entry(e, &wildcard_list, list) {
ff412fb5	308	if (!strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1)) {
e6c12e3d MD	309	found = 1;
	310	break;
	311	}
	312	}
	313
	314	if (!found) {
	315	/*
51c5df09 MD	316	* Create global wildcard entry if not found. Using
	317	* zmalloc here to allocate a variable length element.
	318	* Could cause some memory fragmentation if overused.
e6c12e3d MD	319	*/
	320	e = zmalloc(sizeof(struct wildcard_entry) + name_len);
	321	if (!e)
	322	return ERR_PTR(-ENOMEM);
	323	memcpy(&e->name[0], name, name_len);
	324	cds_list_add(&e->list, &wildcard_list);
	325	CDS_INIT_LIST_HEAD(&e->session_list);
	326	}
	327
	328	/* session wildcard */
	329	cds_list_for_each_entry(sw, &e->session_list, session_list) {
	330	if (chan == sw->chan) {
	331	DBG("wildcard %s busy for this channel", name);
	332	return ERR_PTR(-EEXIST); /* Already there */
	333	}
	334	}
	335	sw = zmalloc(sizeof(struct session_wildcard));
	336	if (!sw)
	337	return ERR_PTR(-ENOMEM);
	338	sw->chan = chan;
	339	sw->enabled = 1;
	340	memcpy(&sw->event_param, event_param, sizeof(sw->event_param));
	341	sw->event_param.instrumentation = LTTNG_UST_TRACEPOINT;
	342	CDS_INIT_LIST_HEAD(&sw->events);
	343	cds_list_add(&sw->list, &chan->session->wildcards);
	344	cds_list_add(&sw->session_list, &e->session_list);
	345	sw->entry = e;
	346	_probes_create_wildcard_events(e, sw);
	347	return sw;
	348	}
	349
	350	/*
51c5df09	351	* Remove the wildcard from the wildcard list. Must be called with
e6c12e3d MD	352	* ust_lock held. Only called at session teardown.
	353	*/
	354	void _remove_wildcard(struct session_wildcard *wildcard)
	355	{
	356	struct ltt_event ev, tmp;
	357
	358	/*
	359	* Just remove the events owned (for enable/disable) by this
	360	* wildcard from the list. The session teardown will take care
	361	* of freeing the event memory.
	362	*/
66221151 MD	363	cds_list_for_each_entry_safe(ev, tmp, &wildcard->events,
	364	wildcard_list) {
	365	cds_list_del(&ev->wildcard_list);
e6c12e3d MD	366	}
	367	cds_list_del(&wildcard->session_list);
	368	cds_list_del(&wildcard->list);
	369	if (cds_list_empty(&wildcard->entry->session_list)) {
	370	cds_list_del(&wildcard->entry->list);
	371	free(wildcard->entry);
	372	}
	373	free(wildcard);
	374	}
	375
	376	int ltt_wildcard_enable(struct session_wildcard *wildcard)
	377	{
	378	struct ltt_event *ev;
	379	int ret;
	380
	381	if (wildcard->enabled)
	382	return -EEXIST;
66221151	383	cds_list_for_each_entry(ev, &wildcard->events, wildcard_list) {
e6c12e3d MD	384	ret = ltt_event_enable(ev);
	385	if (ret) {
	386	DBG("Error: enable error.\n");
	387	return ret;
	388	}
	389	}
	390	wildcard->enabled = 1;
	391	return 0;
	392	}
	393
	394	int ltt_wildcard_disable(struct session_wildcard *wildcard)
	395	{
	396	struct ltt_event *ev;
	397	int ret;
	398
	399	if (!wildcard->enabled)
	400	return -EEXIST;
66221151	401	cds_list_for_each_entry(ev, &wildcard->events, wildcard_list) {
e6c12e3d MD	402	ret = ltt_event_disable(ev);
	403	if (ret) {
	404	DBG("Error: disable error.\n");
	405	return ret;
	406	}
	407	}
	408	wildcard->enabled = 0;
	409	return 0;
	410	}