[lttng-modules.git] / lttng-tracepoint.c

/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
 *
 * lttng-tracepoint.c
 *
 * LTTng adaptation layer for Linux kernel 3.15+ tracepoints.
 *
 * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/notifier.h>
#include <linux/tracepoint.h>
#include <linux/slab.h>
#include <linux/jhash.h>
#include <linux/module.h>

#include <lttng-tracepoint.h>
#include <wrapper/list.h>

/*
 * Protect the tracepoint table. lttng_tracepoint_mutex nests within
 * kernel/tracepoint.c tp_modlist_mutex. kernel/tracepoint.c
 * tracepoint_mutex nests within lttng_tracepoint_mutex.
 */
static
DEFINE_MUTEX(lttng_tracepoint_mutex);

#define TRACEPOINT_HASH_BITS 6
#define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
static
struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];

/*
 * The tracepoint entry is the node contained within the hash table. It
 * is a mapping from the "string" key to the struct tracepoint pointer.
 */
struct tracepoint_entry {
	struct hlist_node hlist;
	struct tracepoint *tp;
	int refcount;
	struct list_head probes;
	char name[0];
};

struct lttng_tp_probe {
	struct tracepoint_func tp_func;
	struct list_head list;
};

static
int add_probe(struct tracepoint_entry *e, void *probe, void *data)
{
	struct lttng_tp_probe *p;
	int found = 0;

	list_for_each_entry(p, &e->probes, list) {
		if (p->tp_func.func == probe && p->tp_func.data == data) {
			found = 1;
			break;
		}
	}
	if (found)
		return -EEXIST;
	p = kmalloc(sizeof(struct lttng_tp_probe), GFP_KERNEL);
	if (!p)
		return -ENOMEM;
	p->tp_func.func = probe;
	p->tp_func.data = data;
	list_add(&p->list, &e->probes);
	return 0;
}

static
int remove_probe(struct tracepoint_entry *e, void *probe, void *data)
{
	struct lttng_tp_probe *p;
	int found = 0;

	list_for_each_entry(p, &e->probes, list) {
		if (p->tp_func.func == probe && p->tp_func.data == data) {
			found = 1;
			break;
		}
	}
	if (found) {
		list_del(&p->list);
		kfree(p);
		return 0;
	} else {
		WARN_ON(1);
		return -ENOENT;
	}
}

/*
 * Get tracepoint if the tracepoint is present in the tracepoint hash table.
 * Must be called with lttng_tracepoint_mutex held.
 * Returns NULL if not present.
 */
static
struct tracepoint_entry *get_tracepoint(const char *name)
{
	struct hlist_head *head;
	struct tracepoint_entry *e;
	u32 hash = jhash(name, strlen(name), 0);

	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
	lttng_hlist_for_each_entry(e, head, hlist) {
		if (!strcmp(name, e->name))
			return e;
	}
	return NULL;
}

/*
 * Add the tracepoint to the tracepoint hash table. Must be called with
 * lttng_tracepoint_mutex held.
 */
static
struct tracepoint_entry *add_tracepoint(const char *name)
{
	struct hlist_head *head;
	struct tracepoint_entry *e;
	size_t name_len = strlen(name) + 1;
	u32 hash = jhash(name, name_len - 1, 0);

	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
	lttng_hlist_for_each_entry(e, head, hlist) {
		if (!strcmp(name, e->name)) {
			printk(KERN_NOTICE
				"tracepoint %s busy\n", name);
			return ERR_PTR(-EEXIST);        /* Already there */
		}
	}
	/*
	 * Using kmalloc here to allocate a variable length element. Could
	 * cause some memory fragmentation if overused.
	 */
	e = kmalloc(sizeof(struct tracepoint_entry) + name_len, GFP_KERNEL);
	if (!e)
		return ERR_PTR(-ENOMEM);
	memcpy(&e->name[0], name, name_len);
	e->tp = NULL;
	e->refcount = 0;
	INIT_LIST_HEAD(&e->probes);
	hlist_add_head(&e->hlist, head);
	return e;
}

/*
 * Remove the tracepoint from the tracepoint hash table. Must be called
 * with lttng_tracepoint_mutex held.
 */
static
void remove_tracepoint(struct tracepoint_entry *e)
{
	hlist_del(&e->hlist);
	kfree(e);
}

int lttng_tracepoint_probe_register(const char *name, void *probe, void *data)
{
	struct tracepoint_entry *e;
	int ret = 0;

	mutex_lock(&lttng_tracepoint_mutex);
	e = get_tracepoint(name);
	if (!e) {
		e = add_tracepoint(name);
		if (IS_ERR(e)) {
			ret = PTR_ERR(e);
			goto end;
		}
	}
	/* add (probe, data) to entry */
	ret = add_probe(e, probe, data);
	if (ret)
		goto end;
	e->refcount++;
	if (e->tp) {
		ret = tracepoint_probe_register(e->tp, probe, data);
		WARN_ON_ONCE(ret);
		ret = 0;
	}
end:
	mutex_unlock(&lttng_tracepoint_mutex);
	return ret;
}

int lttng_tracepoint_probe_unregister(const char *name, void *probe, void *data)
{
	struct tracepoint_entry *e;
	int ret = 0;

	mutex_lock(&lttng_tracepoint_mutex);
	e = get_tracepoint(name);
	if (!e) {
		ret = -ENOENT;
		goto end;
	}
	/* remove (probe, data) from entry */
	ret = remove_probe(e, probe, data);
	if (ret)
		goto end;
	if (e->tp) {
		ret = tracepoint_probe_unregister(e->tp, probe, data);
		WARN_ON_ONCE(ret);
		ret = 0;
	}
	if (!--e->refcount)
		remove_tracepoint(e);
end:
	mutex_unlock(&lttng_tracepoint_mutex);
	return ret;
}

#ifdef CONFIG_MODULES

static
int lttng_tracepoint_coming(struct tp_module *tp_mod)
{
	int i;

	mutex_lock(&lttng_tracepoint_mutex);
	for (i = 0; i < tp_mod->mod->num_tracepoints; i++) {
		struct tracepoint *tp;
		struct tracepoint_entry *e;
		struct lttng_tp_probe *p;

		tp = tp_mod->mod->tracepoints_ptrs[i];
		e = get_tracepoint(tp->name);
		if (!e) {
			e = add_tracepoint(tp->name);
			if (IS_ERR(e)) {
				pr_warn("LTTng: error (%ld) adding tracepoint\n",
					PTR_ERR(e));
				continue;
			}
		}
		/* If already enabled, just check consistency */
		if (e->tp) {
			WARN_ON(e->tp != tp);
			continue;
		}
		e->tp = tp;
		e->refcount++;
		/* register each (probe, data) */
		list_for_each_entry(p, &e->probes, list) {
			int ret;

			ret = tracepoint_probe_register(e->tp,
					p->tp_func.func, p->tp_func.data);
			WARN_ON_ONCE(ret);
		}
	}
	mutex_unlock(&lttng_tracepoint_mutex);
	return 0;
}

static
int lttng_tracepoint_going(struct tp_module *tp_mod)
{
	int i;

	mutex_lock(&lttng_tracepoint_mutex);
	for (i = 0; i < tp_mod->mod->num_tracepoints; i++) {
		struct tracepoint *tp;
		struct tracepoint_entry *e;
		struct lttng_tp_probe *p;

		tp = tp_mod->mod->tracepoints_ptrs[i];
		e = get_tracepoint(tp->name);
		if (!e || !e->tp)
			continue;
		/* unregister each (probe, data) */
		list_for_each_entry(p, &e->probes, list) {
			int ret;

			ret = tracepoint_probe_unregister(e->tp,
					p->tp_func.func, p->tp_func.data);
			WARN_ON_ONCE(ret);
		}
		e->tp = NULL;
		if (!--e->refcount)
			remove_tracepoint(e);
	}
	mutex_unlock(&lttng_tracepoint_mutex);
	return 0;
}

static
int lttng_tracepoint_notify(struct notifier_block *self,
		unsigned long val, void *data)
{
	struct tp_module *tp_mod = data;
	int ret = 0;

	switch (val) {
	case MODULE_STATE_COMING:
		ret = lttng_tracepoint_coming(tp_mod);
		break;
	case MODULE_STATE_GOING:
		ret = lttng_tracepoint_going(tp_mod);
		break;
	default:
		break;
	}
	return ret;
}

static
struct notifier_block lttng_tracepoint_notifier = {
	.notifier_call = lttng_tracepoint_notify,
	.priority = 0,
};

static
int lttng_tracepoint_module_init(void)
{
	return register_tracepoint_module_notifier(&lttng_tracepoint_notifier);
}

static
void lttng_tracepoint_module_exit(void)
{
	WARN_ON(unregister_tracepoint_module_notifier(&lttng_tracepoint_notifier));
}

#else /* #ifdef CONFIG_MODULES */

static
int lttng_tracepoint_module_init(void)
{
	return 0;
}

static
void lttng_tracepoint_module_exit(void)
{
}

#endif /* #else #ifdef CONFIG_MODULES */

static
void lttng_kernel_tracepoint_add(struct tracepoint *tp, void *priv)
{
	struct tracepoint_entry *e;
	struct lttng_tp_probe *p;
	int *ret = priv;

	mutex_lock(&lttng_tracepoint_mutex);
	e = get_tracepoint(tp->name);
	if (!e) {
		e = add_tracepoint(tp->name);
		if (IS_ERR(e)) {
			pr_warn("LTTng: error (%ld) adding tracepoint\n",
				PTR_ERR(e));
			*ret = (int) PTR_ERR(e);
			goto end;
		}
	}
	/* If already enabled, just check consistency */
	if (e->tp) {
		WARN_ON(e->tp != tp);
		goto end;
	}
	e->tp = tp;
	e->refcount++;
	/* register each (probe, data) */
	list_for_each_entry(p, &e->probes, list) {
		int ret;

		ret = tracepoint_probe_register(e->tp,
				p->tp_func.func, p->tp_func.data);
		WARN_ON_ONCE(ret);
	}
end:
	mutex_unlock(&lttng_tracepoint_mutex);
}

static
void lttng_kernel_tracepoint_remove(struct tracepoint *tp, void *priv)
{
	struct tracepoint_entry *e;
	int *ret = priv;

	mutex_lock(&lttng_tracepoint_mutex);
	e = get_tracepoint(tp->name);
	if (!e || e->refcount != 1 || !list_empty(&e->probes)) {
		*ret = -EINVAL;
		goto end;
	}
	remove_tracepoint(e);
end:
	mutex_unlock(&lttng_tracepoint_mutex);
}

int __init lttng_tracepoint_init(void)
{
	int ret = 0;

	for_each_kernel_tracepoint(lttng_kernel_tracepoint_add, &ret);
	if (ret)
		goto error;
	ret = lttng_tracepoint_module_init();
	if (ret)
		goto error_module;
	return 0;

error_module:
	{
		int error_ret = 0;

		for_each_kernel_tracepoint(lttng_kernel_tracepoint_remove,
				&error_ret);
		WARN_ON(error_ret);
	}
error:
	return ret;
}

void lttng_tracepoint_exit(void)
{
	int i, ret = 0;

	lttng_tracepoint_module_exit();
	for_each_kernel_tracepoint(lttng_kernel_tracepoint_remove, &ret);
	WARN_ON(ret);
	mutex_lock(&lttng_tracepoint_mutex);
	for (i = 0; i < TRACEPOINT_TABLE_SIZE; i++) {
		struct hlist_head *head = &tracepoint_table[i];

		/* All tracepoints should be removed */
		WARN_ON(!hlist_empty(head));
	}
	mutex_unlock(&lttng_tracepoint_mutex);
}
Commit	Line	Data
9f36eaed MJ	1	/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
9f36eaed MJ	2	*
20591cf7 MD	3	* lttng-tracepoint.c
	4	*
	5	* LTTng adaptation layer for Linux kernel 3.15+ tracepoints.
	6	*
	7	* Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
20591cf7 MD	8	*/
20591cf7 MD	9
20591cf7 MD	10	#include <linux/mutex.h>
	11	#include <linux/err.h>
	12	#include <linux/notifier.h>
	13	#include <linux/tracepoint.h>
	14	#include <linux/slab.h>
	15	#include <linux/jhash.h>
	16	#include <linux/module.h>
	17
241ae9a8 MD	18	#include <lttng-tracepoint.h>
241ae9a8 MD	19	#include <wrapper/list.h>
20591cf7 MD	20
	21	/*
	22	* Protect the tracepoint table. lttng_tracepoint_mutex nests within
	23	* kernel/tracepoint.c tp_modlist_mutex. kernel/tracepoint.c
	24	* tracepoint_mutex nests within lttng_tracepoint_mutex.
	25	*/
	26	static
	27	DEFINE_MUTEX(lttng_tracepoint_mutex);
	28
	29	#define TRACEPOINT_HASH_BITS 6
	30	#define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
	31	static
	32	struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
	33
	34	/*
	35	* The tracepoint entry is the node contained within the hash table. It
	36	* is a mapping from the "string" key to the struct tracepoint pointer.
	37	*/
	38	struct tracepoint_entry {
	39	struct hlist_node hlist;
	40	struct tracepoint *tp;
	41	int refcount;
	42	struct list_head probes;
	43	char name[0];
	44	};
	45
	46	struct lttng_tp_probe {
	47	struct tracepoint_func tp_func;
	48	struct list_head list;
	49	};
	50
	51	static
	52	int add_probe(struct tracepoint_entry e, void probe, void *data)
	53	{
	54	struct lttng_tp_probe *p;
	55	int found = 0;
	56
	57	list_for_each_entry(p, &e->probes, list) {
	58	if (p->tp_func.func == probe && p->tp_func.data == data) {
	59	found = 1;
	60	break;
	61	}
	62	}
	63	if (found)
	64	return -EEXIST;
	65	p = kmalloc(sizeof(struct lttng_tp_probe), GFP_KERNEL);
	66	if (!p)
	67	return -ENOMEM;
	68	p->tp_func.func = probe;
	69	p->tp_func.data = data;
	70	list_add(&p->list, &e->probes);
	71	return 0;
	72	}
	73
	74	static
	75	int remove_probe(struct tracepoint_entry e, void probe, void *data)
	76	{
	77	struct lttng_tp_probe *p;
	78	int found = 0;
	79
	80	list_for_each_entry(p, &e->probes, list) {
	81	if (p->tp_func.func == probe && p->tp_func.data == data) {
	82	found = 1;
	83	break;
84	}
85	}
86	if (found) {
87	list_del(&p->list);
88	kfree(p);
89	return 0;
90	} else {
91	WARN_ON(1);
92	return -ENOENT;
93	}
94	}
95
96	/*
97	* Get tracepoint if the tracepoint is present in the tracepoint hash table.
98	* Must be called with lttng_tracepoint_mutex held.
99	* Returns NULL if not present.
100	*/
101	static
102	struct tracepoint_entry get_tracepoint(const char name)
103	{
104	struct hlist_head *head;
105	struct tracepoint_entry *e;
106	u32 hash = jhash(name, strlen(name), 0);
107
108	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
f934e302	109	lttng_hlist_for_each_entry(e, head, hlist) {
20591cf7 MD	110	if (!strcmp(name, e->name))
	111	return e;
	112	}
	113	return NULL;
	114	}
	115
	116	/*
	117	* Add the tracepoint to the tracepoint hash table. Must be called with
	118	* lttng_tracepoint_mutex held.
	119	*/
	120	static
	121	struct tracepoint_entry add_tracepoint(const char name)
	122	{
	123	struct hlist_head *head;
	124	struct tracepoint_entry *e;
	125	size_t name_len = strlen(name) + 1;
	126	u32 hash = jhash(name, name_len - 1, 0);
	127
	128	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
f934e302	129	lttng_hlist_for_each_entry(e, head, hlist) {
20591cf7 MD	130	if (!strcmp(name, e->name)) {
	131	printk(KERN_NOTICE
	132	"tracepoint %s busy\n", name);
	133	return ERR_PTR(-EEXIST); /* Already there */
	134	}
	135	}
	136	/*
	137	* Using kmalloc here to allocate a variable length element. Could
	138	* cause some memory fragmentation if overused.
	139	*/
	140	e = kmalloc(sizeof(struct tracepoint_entry) + name_len, GFP_KERNEL);
	141	if (!e)
	142	return ERR_PTR(-ENOMEM);
	143	memcpy(&e->name[0], name, name_len);
	144	e->tp = NULL;
	145	e->refcount = 0;
	146	INIT_LIST_HEAD(&e->probes);
	147	hlist_add_head(&e->hlist, head);
	148	return e;
	149	}
	150
	151	/*
	152	* Remove the tracepoint from the tracepoint hash table. Must be called
	153	* with lttng_tracepoint_mutex held.
	154	*/
	155	static
	156	void remove_tracepoint(struct tracepoint_entry *e)
	157	{
	158	hlist_del(&e->hlist);
	159	kfree(e);
	160	}
	161
	162	int lttng_tracepoint_probe_register(const char name, void probe, void *data)
	163	{
	164	struct tracepoint_entry *e;
	165	int ret = 0;
	166
	167	mutex_lock(&lttng_tracepoint_mutex);
	168	e = get_tracepoint(name);
	169	if (!e) {
	170	e = add_tracepoint(name);
	171	if (IS_ERR(e)) {
	172	ret = PTR_ERR(e);
	173	goto end;
	174	}
	175	}
	176	/* add (probe, data) to entry */
	177	ret = add_probe(e, probe, data);
	178	if (ret)
	179	goto end;
	180	e->refcount++;
	181	if (e->tp) {
	182	ret = tracepoint_probe_register(e->tp, probe, data);
	183	WARN_ON_ONCE(ret);
	184	ret = 0;
	185	}
	186	end:
	187	mutex_unlock(&lttng_tracepoint_mutex);
	188	return ret;
	189	}
	190
	191	int lttng_tracepoint_probe_unregister(const char name, void probe, void *data)
	192	{
	193	struct tracepoint_entry *e;
194	int ret = 0;
195
196	mutex_lock(&lttng_tracepoint_mutex);
197	e = get_tracepoint(name);
198	if (!e) {
199	ret = -ENOENT;
200	goto end;
201	}
202	/* remove (probe, data) from entry */
203	ret = remove_probe(e, probe, data);
204	if (ret)
205	goto end;
206	if (e->tp) {
207	ret = tracepoint_probe_unregister(e->tp, probe, data);
208	WARN_ON_ONCE(ret);
209	ret = 0;
210	}
211	if (!--e->refcount)
212	remove_tracepoint(e);
213	end:
214	mutex_unlock(&lttng_tracepoint_mutex);
215	return ret;
216	}
217
218	#ifdef CONFIG_MODULES
219
220	static
221	int lttng_tracepoint_coming(struct tp_module *tp_mod)
222	{
223	int i;
224
225	mutex_lock(&lttng_tracepoint_mutex);
226	for (i = 0; i < tp_mod->mod->num_tracepoints; i++) {
227	struct tracepoint *tp;
228	struct tracepoint_entry *e;
229	struct lttng_tp_probe *p;
230
231	tp = tp_mod->mod->tracepoints_ptrs[i];
232	e = get_tracepoint(tp->name);
233	if (!e) {
234	e = add_tracepoint(tp->name);
235	if (IS_ERR(e)) {
236	pr_warn("LTTng: error (%ld) adding tracepoint\n",
237	PTR_ERR(e));
238	continue;
239	}
240	}
241	/* If already enabled, just check consistency */
242	if (e->tp) {
243	WARN_ON(e->tp != tp);
244	continue;
245	}
246	e->tp = tp;
247	e->refcount++;
248	/* register each (probe, data) */
249	list_for_each_entry(p, &e->probes, list) {
250	int ret;
251
252	ret = tracepoint_probe_register(e->tp,
253	p->tp_func.func, p->tp_func.data);
254	WARN_ON_ONCE(ret);
255	}
256	}
257	mutex_unlock(&lttng_tracepoint_mutex);
258	return 0;
259	}
260
261	static
262	int lttng_tracepoint_going(struct tp_module *tp_mod)
263	{
264	int i;
265
266	mutex_lock(&lttng_tracepoint_mutex);
267	for (i = 0; i < tp_mod->mod->num_tracepoints; i++) {
268	struct tracepoint *tp;
269	struct tracepoint_entry *e;
270	struct lttng_tp_probe *p;
271
272	tp = tp_mod->mod->tracepoints_ptrs[i];
273	e = get_tracepoint(tp->name);
274	if (!e \|\| !e->tp)
275	continue;
276	/* unregister each (probe, data) */
277	list_for_each_entry(p, &e->probes, list) {
278	int ret;
279
280	ret = tracepoint_probe_unregister(e->tp,
281	p->tp_func.func, p->tp_func.data);
282	WARN_ON_ONCE(ret);
283	}
284	e->tp = NULL;
285	if (!--e->refcount)
286	remove_tracepoint(e);
287	}
288	mutex_unlock(&lttng_tracepoint_mutex);
289	return 0;
290	}
291
292	static
293	int lttng_tracepoint_notify(struct notifier_block *self,
294	unsigned long val, void *data)
295	{
296	struct tp_module *tp_mod = data;
297	int ret = 0;
298
299	switch (val) {
300	case MODULE_STATE_COMING:
301	ret = lttng_tracepoint_coming(tp_mod);
302	break;
303	case MODULE_STATE_GOING:
304	ret = lttng_tracepoint_going(tp_mod);
305	break;
306	default:
307	break;
308	}
309	return ret;
310	}
311
312	static
313	struct notifier_block lttng_tracepoint_notifier = {
314	.notifier_call = lttng_tracepoint_notify,
315	.priority = 0,
316	};
317
318	static
319	int lttng_tracepoint_module_init(void)
320	{
321	return register_tracepoint_module_notifier(&lttng_tracepoint_notifier);
322	}
323
324	static
325	void lttng_tracepoint_module_exit(void)
326	{
327	WARN_ON(unregister_tracepoint_module_notifier(&lttng_tracepoint_notifier));
328	}
329
330	#else /* #ifdef CONFIG_MODULES */
331
332	static
333	int lttng_tracepoint_module_init(void)
334	{
335	return 0;
336	}
337
338	static
339	void lttng_tracepoint_module_exit(void)
340	{
341	}
342
343	#endif /* #else #ifdef CONFIG_MODULES */
344
345	static
346	void lttng_kernel_tracepoint_add(struct tracepoint tp, void priv)
347	{
348	struct tracepoint_entry *e;
349	struct lttng_tp_probe *p;
350	int *ret = priv;
351
352	mutex_lock(&lttng_tracepoint_mutex);
353	e = get_tracepoint(tp->name);
354	if (!e) {
355	e = add_tracepoint(tp->name);
356	if (IS_ERR(e)) {
357	pr_warn("LTTng: error (%ld) adding tracepoint\n",
358	PTR_ERR(e));
359	*ret = (int) PTR_ERR(e);
360	goto end;
361	}
362	}
363	/* If already enabled, just check consistency */
364	if (e->tp) {
365	WARN_ON(e->tp != tp);
366	goto end;
367	}
368	e->tp = tp;
369	e->refcount++;
370	/* register each (probe, data) */
371	list_for_each_entry(p, &e->probes, list) {
372	int ret;
373
374	ret = tracepoint_probe_register(e->tp,
375	p->tp_func.func, p->tp_func.data);
376	WARN_ON_ONCE(ret);
377	}
378	end:
379	mutex_unlock(&lttng_tracepoint_mutex);
380	}
381
382	static
383	void lttng_kernel_tracepoint_remove(struct tracepoint tp, void priv)
384	{
385	struct tracepoint_entry *e;
386	int *ret = priv;
387
388	mutex_lock(&lttng_tracepoint_mutex);
389	e = get_tracepoint(tp->name);
390	if (!e \|\| e->refcount != 1 \|\| !list_empty(&e->probes)) {
391	*ret = -EINVAL;
392	goto end;
393	}
394	remove_tracepoint(e);
395	end:
396	mutex_unlock(&lttng_tracepoint_mutex);
397	}
398
399	int __init lttng_tracepoint_init(void)
400	{
401	int ret = 0;
402
403	for_each_kernel_tracepoint(lttng_kernel_tracepoint_add, &ret);
404	if (ret)
405	goto error;
406	ret = lttng_tracepoint_module_init();
407	if (ret)
408	goto error_module;
409	return 0;
410
411	error_module:
412	{
413	int error_ret = 0;
414
415	for_each_kernel_tracepoint(lttng_kernel_tracepoint_remove,
416	&error_ret);
417	WARN_ON(error_ret);
418	}
419	error:
420	return ret;
421	}
422
423	void lttng_tracepoint_exit(void)
424	{
425	int i, ret = 0;
426
427	lttng_tracepoint_module_exit();
428	for_each_kernel_tracepoint(lttng_kernel_tracepoint_remove, &ret);
429	WARN_ON(ret);
430	mutex_lock(&lttng_tracepoint_mutex);
431	for (i = 0; i < TRACEPOINT_TABLE_SIZE; i++) {
432	struct hlist_head *head = &tracepoint_table[i];
433
434	/* All tracepoints should be removed */
435	WARN_ON(!hlist_empty(head));
436	}
437	mutex_unlock(&lttng_tracepoint_mutex);
438	}