[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);

/*
 * 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)
{
	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 (!strcmp(probe_desc->event_desc[i]->name, name))
				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:

	/*
	 * 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);
	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;
}

/*
 * 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)
{
	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;
	}
	return NULL;
}

struct loglevel_entry *get_loglevel_value(int64_t value)
{
	char name[LTTNG_UST_SYM_NAME_LEN];
	int ret;

	ret = snprintf(name, LTTNG_UST_SYM_NAME_LEN, "%lld", (long long) value);
	if (ret < 0)
		return NULL;
	return get_loglevel(name);
}

/*
 * marshall all probes/all events and create those that fit the
 * loglevel. Add them to the events list as created.
 */
static
void _probes_create_loglevel_events(struct loglevel_entry *entry,
				struct session_loglevel *loglevel)
{
	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 tracepoint_loglevel_entry *ev_ll;
			const struct lttng_event_desc *event_desc;
			int match = 0;

			event_desc = probe_desc->event_desc[i];
			if (!(event_desc->loglevel))
				continue;
			ev_ll = *event_desc->loglevel;
			if (isdigit(entry->name[0])) {
				if (atoll(entry->name) == ev_ll->value) {
					match = 1;
				}
			} else if (!strcmp(ev_ll->identifier, entry->name)) {
				match = 1;
			}

			if (match) {
				struct ltt_event *ev;
				int ret;

				memcpy(&event_param, &loglevel->event_param,
						sizeof(event_param));
				memcpy(event_param.name,
					event_desc->name,
					sizeof(event_param.name));
				/* create event */
				ret = ltt_event_create(loglevel->chan,
					&event_param, NULL,
					&ev);
				if (ret) {
					DBG("Error creating event");
					continue;
				}
				cds_list_add(&ev->loglevel_list,
					&loglevel->events);
			}
		}
	}
}

/*
 * Add the loglevel to the loglevel hash table. Must be called with
 * ust lock held.
 */
struct session_loglevel *add_loglevel(const char *name,
	struct ltt_channel *chan,
	struct lttng_ust_event *event_param)
{
	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);
		CDS_INIT_LIST_HEAD(&e->session_list);
	}

	/* 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));
	sl->event_param.instrumentation = LTTNG_UST_TRACEPOINT;
	CDS_INIT_LIST_HEAD(&sl->events);
	cds_list_add(&sl->list, &chan->session->loglevels);
	cds_list_add(&sl->session_list, &e->session_list);
	sl->entry = e;
	_probes_create_loglevel_events(e, sl);
	return sl;
}

/*
 * Remove the loglevel from the loglevel hash table. Must be called with
 * ust_lock held. Only called at session teardown.
 */
void _remove_loglevel(struct session_loglevel *loglevel)
{
	struct ltt_event *ev, *tmp;

	/*
	 * 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);
}

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;
		}
	}
	loglevel->enabled = 1;
	return 0;
}

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;
}
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
1f18504e MD	29	/*
	30	* Loglevel hash table, containing the active loglevels.
	31	* Protected by ust lock.
	32	*/
	33	#define LOGLEVEL_HASH_BITS 6
	34	#define LOGLEVEL_TABLE_SIZE (1 << LOGLEVEL_HASH_BITS)
	35	static struct cds_hlist_head loglevel_table[LOGLEVEL_TABLE_SIZE];
	36
df854e41 MD	37	static
	38	const struct lttng_probe_desc find_provider(const char provider)
	39	{
	40	struct lttng_probe_desc *iter;
	41
	42	cds_list_for_each_entry(iter, &probe_list, head) {
	43	if (!strcmp(iter->provider, provider))
	44	return iter;
	45	}
	46	return NULL;
	47	}
	48
ce5aef0b MD	49	static
	50	const struct lttng_event_desc find_event(const char name)
	51	{
	52	struct lttng_probe_desc *probe_desc;
	53	int i;
	54
8d8a24c8	55	cds_list_for_each_entry(probe_desc, &probe_list, head) {
ce5aef0b	56	for (i = 0; i < probe_desc->nr_events; i++) {
df854e41 MD	57	if (!strcmp(probe_desc->event_desc[i]->name, name))
df854e41 MD	58	return probe_desc->event_desc[i];
ce5aef0b MD	59	}
	60	}
	61	return NULL;
	62	}
	63
	64	int ltt_probe_register(struct lttng_probe_desc *desc)
	65	{
df854e41	66	struct lttng_probe_desc *iter;
ce5aef0b MD	67	int ret = 0;
	68	int i;
	69
17dfb34b	70	ust_lock();
df854e41 MD	71	if (find_provider(desc->provider)) {
	72	ret = -EEXIST;
	73	goto end;
	74	}
ce5aef0b MD	75	/*
	76	* TODO: This is O(N^2). Turn into a hash table when probe registration
	77	* overhead becomes an issue.
	78	*/
	79	for (i = 0; i < desc->nr_events; i++) {
df854e41	80	if (find_event(desc->event_desc[i]->name)) {
ce5aef0b MD	81	ret = -EEXIST;
	82	goto end;
	83	}
	84	}
df854e41 MD	85
	86	/*
	87	* We sort the providers by struct lttng_probe_desc pointer
	88	* address.
	89	*/
	90	cds_list_for_each_entry_reverse(iter, &probe_list, head) {
	91	BUG_ON(iter == desc); /* Should never be in the list twice */
	92	if (iter < desc) {
	93	/* We belong to the location right after iter. */
	94	cds_list_add(&desc->head, &iter->head);
	95	goto desc_added;
	96	}
	97	}
	98	/* We should be added at the head of the list */
8d8a24c8	99	cds_list_add(&desc->head, &probe_list);
df854e41	100	desc_added:
8165c8da MD	101
	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);
17dfb34b	118	ust_unlock();
ce5aef0b	119	}
ce5aef0b	120
8165c8da MD	121	/*
	122	* called with UST lock held.
	123	*/
ce5aef0b MD	124	const struct lttng_event_desc ltt_event_get(const char name)
	125	{
	126	const struct lttng_event_desc *event;
ce5aef0b	127
ce5aef0b	128	event = find_event(name);
ce5aef0b MD	129	if (!event)
ce5aef0b MD	130	return NULL;
ce5aef0b MD	131	return event;
ce5aef0b MD	132	}
ce5aef0b MD	133
	134	void ltt_event_put(const struct lttng_event_desc *event)
	135	{
ce5aef0b	136	}
c8fcf224 MD	137
	138	void ltt_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
	139	{
	140	struct tp_list_entry list_entry, tmp;
	141
	142	cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
	143	cds_list_del(&list_entry->head);
	144	free(list_entry);
	145	}
	146	}
	147
	148	/*
	149	* called with UST lock held.
	150	*/
	151	int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
	152	{
	153	struct lttng_probe_desc *probe_desc;
	154	int i;
	155
	156	CDS_INIT_LIST_HEAD(&list->head);
	157	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	158	for (i = 0; i < probe_desc->nr_events; i++) {
	159	struct tp_list_entry *list_entry;
	160
	161	list_entry = zmalloc(sizeof(*list_entry));
	162	if (!list_entry)
	163	goto err_nomem;
	164	cds_list_add(&list_entry->head, &list->head);
	165	strncpy(list_entry->tp.name,
	166	probe_desc->event_desc[i]->name,
	167	LTTNG_UST_SYM_NAME_LEN);
	168	list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	169	if (!probe_desc->event_desc[i]->loglevel) {
	170	list_entry->tp.loglevel[0] = '\0';
	171	list_entry->tp.loglevel_value = 0;
	172	} else {
	173	strncpy(list_entry->tp.loglevel,
	174	(*probe_desc->event_desc[i]->loglevel)->identifier,
	175	LTTNG_UST_SYM_NAME_LEN);
	176	list_entry->tp.loglevel[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	177	list_entry->tp.loglevel_value =
	178	(*probe_desc->event_desc[i]->loglevel)->value;
	179	}
	180	}
	181	}
	182	if (cds_list_empty(&list->head))
	183	list->iter = NULL;
	184	else
	185	list->iter =
	186	cds_list_first_entry(&list->head, struct tp_list_entry, head);
	187	return 0;
	188
	189	err_nomem:
	190	ltt_probes_prune_event_list(list);
	191	return -ENOMEM;
	192	}
	193
	194	/*
	195	* Return current iteration position, advance internal iterator to next.
	196	* Return NULL if end of list.
	197	*/
	198	struct lttng_ust_tracepoint_iter *
	199	lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
	200	{
201	struct tp_list_entry *entry;
202
203	if (!list->iter)
204	return NULL;
205	entry = list->iter;
206	if (entry->head.next == &list->head)
207	list->iter = NULL;
208	else
209	list->iter = cds_list_entry(entry->head.next,
210	struct tp_list_entry, head);
211	return &entry->tp;
212	}
1f18504e MD	213
	214	/*
	215	* Get loglevel if the loglevel is present in the loglevel hash table.
	216	* Must be called with ust lock held.
	217	* Returns NULL if not present.
	218	*/
	219	struct loglevel_entry get_loglevel(const char name)
	220	{
	221	struct cds_hlist_head *head;
	222	struct cds_hlist_node *node;
	223	struct loglevel_entry *e;
	224	uint32_t hash = jhash(name, strlen(name), 0);
	225
	226	head = &loglevel_table[hash & (LOGLEVEL_TABLE_SIZE - 1)];
	227	cds_hlist_for_each_entry(e, node, head, hlist) {
	228	if (!strcmp(name, e->name))
	229	return e;
	230	}
	231	return NULL;
	232	}
	233
48740cab MD	234	struct loglevel_entry *get_loglevel_value(int64_t value)
	235	{
	236	char name[LTTNG_UST_SYM_NAME_LEN];
	237	int ret;
	238
	239	ret = snprintf(name, LTTNG_UST_SYM_NAME_LEN, "%lld", (long long) value);
	240	if (ret < 0)
	241	return NULL;
	242	return get_loglevel(name);
	243	}
	244
1f18504e MD	245	/*
	246	* marshall all probes/all events and create those that fit the
	247	* loglevel. Add them to the events list as created.
	248	*/
	249	static
574a6217 MD	250	void _probes_create_loglevel_events(struct loglevel_entry *entry,
574a6217 MD	251	struct session_loglevel *loglevel)
1f18504e MD	252	{
1f18504e MD	253	struct lttng_probe_desc *probe_desc;
7ee3cc56	254	struct lttng_ust_event event_param;
1f18504e MD	255	int i;
	256
	257	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	258	for (i = 0; i < probe_desc->nr_events; i++) {
	259	const struct tracepoint_loglevel_entry *ev_ll;
7ee3cc56	260	const struct lttng_event_desc *event_desc;
5e87eb4a	261	int match = 0;
1f18504e	262
7ee3cc56 MD	263	event_desc = probe_desc->event_desc[i];
7ee3cc56 MD	264	if (!(event_desc->loglevel))
1f18504e	265	continue;
7ee3cc56	266	ev_ll = *event_desc->loglevel;
3431ca3e	267	if (isdigit(entry->name[0])) {
48740cab MD	268	if (atoll(entry->name) == ev_ll->value) {
	269	match = 1;
	270	}
	271	} else if (!strcmp(ev_ll->identifier, entry->name)) {
	272	match = 1;
	273	}
	274
	275	if (match) {
1f18504e MD	276	struct ltt_event *ev;
	277	int ret;
	278
7ee3cc56 MD	279	memcpy(&event_param, &loglevel->event_param,
	280	sizeof(event_param));
	281	memcpy(event_param.name,
	282	event_desc->name,
	283	sizeof(event_param.name));
1f18504e MD	284	/* create event */
1f18504e MD	285	ret = ltt_event_create(loglevel->chan,
7ee3cc56	286	&event_param, NULL,
1f18504e	287	&ev);
7ee3cc56 MD	288	if (ret) {
7ee3cc56 MD	289	DBG("Error creating event");
1f18504e	290	continue;
7ee3cc56	291	}
1f18504e MD	292	cds_list_add(&ev->loglevel_list,
	293	&loglevel->events);
	294	}
1f18504e MD	295	}
	296	}
	297	}
	298
	299	/*
	300	* Add the loglevel to the loglevel hash table. Must be called with
	301	* ust lock held.
	302	*/
574a6217	303	struct session_loglevel add_loglevel(const char name,
1f18504e MD	304	struct ltt_channel *chan,
	305	struct lttng_ust_event *event_param)
	306	{
	307	struct cds_hlist_head *head;
	308	struct cds_hlist_node *node;
	309	struct loglevel_entry *e;
574a6217	310	struct session_loglevel *sl;
1f18504e MD	311	size_t name_len = strlen(name) + 1;
1f18504e MD	312	uint32_t hash = jhash(name, name_len-1, 0);
574a6217	313	int found = 0;
1f18504e	314
574a6217	315	/* loglevel entry */
1f18504e MD	316	head = &loglevel_table[hash & (LOGLEVEL_TABLE_SIZE - 1)];
	317	cds_hlist_for_each_entry(e, node, head, hlist) {
	318	if (!strcmp(name, e->name)) {
574a6217 MD	319	found = 1;
	320	break;
	321	}
	322	}
	323
	324	if (!found) {
	325	/*
	326	* Using zmalloc here to allocate a variable length element. Could
	327	* cause some memory fragmentation if overused.
	328	*/
	329	e = zmalloc(sizeof(struct loglevel_entry) + name_len);
	330	if (!e)
	331	return ERR_PTR(-ENOMEM);
	332	memcpy(&e->name[0], name, name_len);
	333	cds_hlist_add_head(&e->hlist, head);
d5201d38	334	CDS_INIT_LIST_HEAD(&e->session_list);
574a6217 MD	335	}
	336
	337	/* session loglevel */
	338	cds_list_for_each_entry(sl, &e->session_list, session_list) {
	339	if (chan == sl->chan) {
	340	DBG("loglevel %s busy for this channel", name);
1f18504e MD	341	return ERR_PTR(-EEXIST); /* Already there */
	342	}
	343	}
574a6217 MD	344	sl = zmalloc(sizeof(struct session_loglevel));
574a6217 MD	345	if (!sl)
1f18504e	346	return ERR_PTR(-ENOMEM);
574a6217 MD	347	sl->chan = chan;
	348	sl->enabled = 1;
	349	memcpy(&sl->event_param, event_param, sizeof(sl->event_param));
d5201d38	350	sl->event_param.instrumentation = LTTNG_UST_TRACEPOINT;
574a6217 MD	351	CDS_INIT_LIST_HEAD(&sl->events);
	352	cds_list_add(&sl->list, &chan->session->loglevels);
	353	cds_list_add(&sl->session_list, &e->session_list);
2981744d	354	sl->entry = e;
574a6217 MD	355	_probes_create_loglevel_events(e, sl);
574a6217 MD	356	return sl;
1f18504e MD	357	}
	358
	359	/*
	360	* Remove the loglevel from the loglevel hash table. Must be called with
	361	* ust_lock held. Only called at session teardown.
	362	*/
574a6217	363	void _remove_loglevel(struct session_loglevel *loglevel)
1f18504e MD	364	{
	365	struct ltt_event ev, tmp;
	366
	367	/*
	368	* Just remove the events owned (for enable/disable) by this
	369	* loglevel from the list. The session teardown will take care
	370	* of freeing the event memory.
	371	*/
	372	cds_list_for_each_entry_safe(ev, tmp, &loglevel->events, list) {
	373	cds_list_del(&ev->list);
	374	}
574a6217	375	cds_list_del(&loglevel->session_list);
1f18504e	376	cds_list_del(&loglevel->list);
574a6217 MD	377	if (cds_list_empty(&loglevel->entry->session_list)) {
	378	cds_hlist_del(&loglevel->entry->hlist);
	379	free(loglevel->entry);
	380	}
1f18504e MD	381	free(loglevel);
	382	}
	383
574a6217	384	int ltt_loglevel_enable(struct session_loglevel *loglevel)
1f18504e MD	385	{
	386	struct ltt_event *ev;
	387	int ret;
	388
	389	if (loglevel->enabled)
	390	return -EEXIST;
	391	cds_list_for_each_entry(ev, &loglevel->events, list) {
	392	ret = ltt_event_enable(ev);
	393	if (ret) {
	394	DBG("Error: enable error.\n");
	395	return ret;
	396	}
	397	}
	398	loglevel->enabled = 1;
	399	return 0;
	400	}
	401
574a6217	402	int ltt_loglevel_disable(struct session_loglevel *loglevel)
1f18504e MD	403	{
	404	struct ltt_event *ev;
	405	int ret;
	406
	407	if (!loglevel->enabled)
	408	return -EEXIST;
	409	cds_list_for_each_entry(ev, &loglevel->events, list) {
	410	ret = ltt_event_disable(ev);
	411	if (ret) {
	412	DBG("Error: disable error.\n");
	413	return ret;
	414	}
	415	}
	416	loglevel->enabled = 0;
	417	return 0;
	418	}