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

			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';
				if (!event_desc->loglevel) {
					list_entry->field.loglevel = TRACE_DEFAULT;
				} else {
					list_entry->field.loglevel = *(*event_desc->loglevel);
				}
			}
		}
	}
	if (cds_list_empty(&list->head))
		list->iter = NULL;
	else
		list->iter =
			cds_list_first_entry(&list->head,
				struct tp_field_list_entry, head);
	return 0;

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

/*
 * 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));
				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);
			}
		}
	}
}
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
	247	for (j = 0; j < event_desc->nr_fields; j++) {
	248	const struct lttng_event_field *event_field =
	249	&event_desc->fields[j];
	250	struct tp_field_list_entry *list_entry;
	251
	252	list_entry = zmalloc(sizeof(*list_entry));
	253	if (!list_entry)
	254	goto err_nomem;
	255	cds_list_add(&list_entry->head, &list->head);
	256	strncpy(list_entry->field.event_name,
	257	event_desc->name,
	258	LTTNG_UST_SYM_NAME_LEN);
	259	list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	260	strncpy(list_entry->field.field_name,
	261	event_field->name,
	262	LTTNG_UST_SYM_NAME_LEN);
	263	list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	264	if (!event_desc->loglevel) {
	265	list_entry->field.loglevel = TRACE_DEFAULT;
	266	} else {
	267	list_entry->field.loglevel = (event_desc->loglevel);
	268	}
	269	}
	270	}
	271	}
	272	if (cds_list_empty(&list->head))
	273	list->iter = NULL;
	274	else
	275	list->iter =
	276	cds_list_first_entry(&list->head,
	277	struct tp_field_list_entry, head);
	278	return 0;
	279
	280	err_nomem:
	281	ltt_probes_prune_field_list(list);
	282	return -ENOMEM;
	283	}
	284
	285	/*
286	* Return current iteration position, advance internal iterator to next.
287	* Return NULL if end of list.
288	*/
289	struct lttng_ust_field_iter *
290	lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
291	{
292	struct tp_field_list_entry *entry;
293
294	if (!list->iter)
295	return NULL;
296	entry = list->iter;
297	if (entry->head.next == &list->head)
298	list->iter = NULL;
299	else
300	list->iter = cds_list_entry(entry->head.next,
301	struct tp_field_list_entry, head);
302	return &entry->field;
303	}
304
e6c12e3d MD	305	/*
	306	* marshall all probes/all events and create those that fit the
	307	* wildcard. Add them to the events list as created.
	308	*/
457a6b58	309	void ltt_probes_create_wildcard_events(struct wildcard_entry *entry,
e6c12e3d MD	310	struct session_wildcard *wildcard)
	311	{
	312	struct lttng_probe_desc *probe_desc;
	313	struct lttng_ust_event event_param;
	314	int i;
	315
	316	cds_list_for_each_entry(probe_desc, &probe_list, head) {
	317	for (i = 0; i < probe_desc->nr_events; i++) {
	318	const struct lttng_event_desc *event_desc;
	319	int match = 0;
	320
	321	event_desc = probe_desc->event_desc[i];
	322	/* compare excluding final '' /
	323	assert(strlen(entry->name) > 0);
	324	if (strcmp(event_desc->name, "lttng_ust:metadata")
	325	&& (strlen(entry->name) == 1
	326	\|\| !strncmp(event_desc->name, entry->name,
	327	strlen(entry->name) - 1))) {
457a6b58 MD	328	if (ltt_loglevel_match(event_desc,
	329	entry->loglevel_type,
	330	entry->loglevel)) {
	331	match = 1;
	332	}
e6c12e3d MD	333	}
	334	if (match) {
	335	struct ltt_event *ev;
	336	int ret;
	337
	338	memcpy(&event_param, &wildcard->event_param,
	339	sizeof(event_param));
	340	memcpy(event_param.name,
	341	event_desc->name,
	342	sizeof(event_param.name));
	343	/* create event */
	344	ret = ltt_event_create(wildcard->chan,
	345	&event_param, NULL,
	346	&ev);
	347	if (ret) {
	348	DBG("Error creating event");
	349	continue;
	350	}
	351	cds_list_add(&ev->wildcard_list,
	352	&wildcard->events);
	353	}
	354	}
	355	}
	356	}
	357