[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>
#include <wrapper/tracepoint.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 = lttng_tracepoint_ptr_deref(&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 NOTIFY_OK;
}

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