[lttng-modules.git] / src / lttng-probes.c

/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
 *
 * lttng-probes.c
 *
 * Holds LTTng probes registry.
 *
 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#include <linux/module.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/seq_file.h>

#include <lttng/events.h>

/*
 * probe list is protected by sessions lock.
 */
static LIST_HEAD(_probe_list);

/*
 * List of probes registered by not yet processed.
 */
static LIST_HEAD(lazy_probe_init);

/*
 * lazy_nesting counter ensures we don't notify lazy probe registration
 * fixup while we are performing the fixup. It is protected by the
 * sessions lock.
 */
static int lazy_nesting;

DEFINE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);

EXPORT_PER_CPU_SYMBOL_GPL(lttng_dynamic_len_stack);

/*
 * Called under sessions lock.
 */
static
int check_event_provider(struct lttng_kernel_probe_desc *desc)
{
	int i;
	size_t provider_name_len;

	provider_name_len = strnlen(desc->provider_name,
				LTTNG_KERNEL_SYM_NAME_LEN - 1);
	for (i = 0; i < desc->nr_events; i++) {
		if (strncmp(desc->event_desc[i]->event_name,
				desc->provider_name,
				provider_name_len))
			return 0;	/* provider mismatch */
		/*
		 * The event needs to contain at least provider name + _ +
		 * one or more letter.
		 */
		if (strlen(desc->event_desc[i]->event_name) <= provider_name_len + 1)
			return 0;	/* provider mismatch */
		if (desc->event_desc[i]->event_name[provider_name_len] != '_')
			return 0;	/* provider mismatch */
	}
	return 1;
}

/*
 * Called under sessions lock.
 */
static
void lttng_lazy_probe_register(struct lttng_kernel_probe_desc *desc)
{
	struct lttng_kernel_probe_desc *iter;
	struct list_head *probe_list;

	/*
	 * Each provider enforce that every event name begins with the
	 * provider name. Check this in an assertion for extra
	 * carefulness. This ensures we cannot have duplicate event
	 * names across providers.
	 */
	WARN_ON_ONCE(!check_event_provider(desc));

	/*
	 * The provider ensures there are no duplicate event names.
	 * Duplicated TRACEPOINT_EVENT event names would generate a
	 * compile-time error due to duplicated symbol names.
	 */

	/*
	 * We sort the providers by struct lttng_kernel_probe_desc pointer
	 * address.
	 */
	probe_list = &_probe_list;
	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. */
			list_add(&desc->head, &iter->head);
			goto desc_added;
		}
	}
	/* We should be added at the head of the list */
	list_add(&desc->head, probe_list);
desc_added:
	pr_debug("LTTng: just registered probe %s containing %u events\n",
		desc->provider_name, desc->nr_events);
}

/*
 * Called under sessions lock.
 */
static
void fixup_lazy_probes(void)
{
	struct lttng_kernel_probe_desc *iter, *tmp;
	int ret;

	lazy_nesting++;
	list_for_each_entry_safe(iter, tmp,
			&lazy_probe_init, lazy_init_head) {
		lttng_lazy_probe_register(iter);
		iter->lazy = 0;
		list_del(&iter->lazy_init_head);
	}
	ret = lttng_fix_pending_events();
	WARN_ON_ONCE(ret);
	ret = lttng_fix_pending_event_notifiers();
	WARN_ON_ONCE(ret);
	lazy_nesting--;
}

/*
 * Called under sessions lock.
 */
struct list_head *lttng_get_probe_list_head(void)
{
	if (!lazy_nesting && !list_empty(&lazy_probe_init))
		fixup_lazy_probes();
	return &_probe_list;
}

static
const struct lttng_kernel_probe_desc *find_provider(const char *provider)
{
	struct lttng_kernel_probe_desc *iter;
	struct list_head *probe_list;

	probe_list = lttng_get_probe_list_head();
	list_for_each_entry(iter, probe_list, head) {
		if (!strcmp(iter->provider_name, provider))
			return iter;
	}
	return NULL;
}

int lttng_probe_register(struct lttng_kernel_probe_desc *desc)
{
	int ret = 0;

	lttng_lock_sessions();

	/*
	 * Check if the provider has already been registered.
	 */
	if (find_provider(desc->provider_name)) {
		ret = -EEXIST;
		goto end;
	}
	list_add(&desc->lazy_init_head, &lazy_probe_init);
	desc->lazy = 1;
	pr_debug("LTTng: adding probe %s containing %u events to lazy registration list\n",
		desc->provider_name, desc->nr_events);
	/*
	 * If there is at least one active session, we need to register
	 * the probe immediately, since we cannot delay event
	 * registration because they are needed ASAP.
	 */
	if (lttng_session_active() || lttng_event_notifier_active())
		fixup_lazy_probes();
end:
	lttng_unlock_sessions();
	return ret;
}
EXPORT_SYMBOL_GPL(lttng_probe_register);

void lttng_probe_unregister(struct lttng_kernel_probe_desc *desc)
{
	lttng_lock_sessions();
	if (!desc->lazy)
		list_del(&desc->head);
	else
		list_del(&desc->lazy_init_head);
	pr_debug("LTTng: just unregistered probe %s\n", desc->provider_name);
	lttng_unlock_sessions();
}
EXPORT_SYMBOL_GPL(lttng_probe_unregister);

/*
 * TODO: this is O(nr_probes * nb_events), could be faster.
 * Called with sessions lock held.
 */
static
const struct lttng_kernel_event_desc *find_event_desc(const char *name)
{
	struct lttng_kernel_probe_desc *probe_desc;
	int i;

	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]->event_name, name))
				return probe_desc->event_desc[i];
			}
	}
	return NULL;
}

/*
 * Called with sessions lock held.
 */
const struct lttng_kernel_event_desc *lttng_event_desc_get(const char *name)
{
	const struct lttng_kernel_event_desc *event_desc;
	int ret;

	event_desc = find_event_desc(name);
	if (!event_desc)
		return NULL;
	ret = try_module_get(event_desc->owner);
	WARN_ON_ONCE(!ret);
	return event_desc;
}
EXPORT_SYMBOL_GPL(lttng_event_desc_get);

/*
 * Called with sessions lock held.
 */
void lttng_event_desc_put(const struct lttng_kernel_event_desc *event_desc)
{
	module_put(event_desc->owner);
}
EXPORT_SYMBOL_GPL(lttng_event_desc_put);

static
void *tp_list_start(struct seq_file *m, loff_t *pos)
{
	struct lttng_kernel_probe_desc *probe_desc;
	struct list_head *probe_list;
	int iter = 0, i;

	lttng_lock_sessions();
	probe_list = lttng_get_probe_list_head();
	list_for_each_entry(probe_desc, probe_list, head) {
		for (i = 0; i < probe_desc->nr_events; i++) {
			if (iter++ >= *pos)
				return (void *) probe_desc->event_desc[i];
		}
	}
	/* End of list */
	return NULL;
}

static
void *tp_list_next(struct seq_file *m, void *p, loff_t *ppos)
{
	struct lttng_kernel_probe_desc *probe_desc;
	struct list_head *probe_list;
	int iter = 0, i;

	(*ppos)++;
	probe_list = lttng_get_probe_list_head();
	list_for_each_entry(probe_desc, probe_list, head) {
		for (i = 0; i < probe_desc->nr_events; i++) {
			if (iter++ >= *ppos)
				return (void *) probe_desc->event_desc[i];
		}
	}
	/* End of list */
	return NULL;
}

static
void tp_list_stop(struct seq_file *m, void *p)
{
	lttng_unlock_sessions();
}

static
int tp_list_show(struct seq_file *m, void *p)
{
	const struct lttng_kernel_event_desc *probe_desc = p;

	seq_printf(m,	"event { name = %s; };\n",
		   probe_desc->event_name);
	return 0;
}

static
const struct seq_operations lttng_tracepoint_list_seq_ops = {
	.start = tp_list_start,
	.next = tp_list_next,
	.stop = tp_list_stop,
	.show = tp_list_show,
};

static
int lttng_tracepoint_list_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &lttng_tracepoint_list_seq_ops);
}

const struct file_operations lttng_tracepoint_list_fops = {
	.owner = THIS_MODULE,
	.open = lttng_tracepoint_list_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
};

int lttng_probes_init(void)
{
	int cpu;

	for_each_possible_cpu(cpu)
		per_cpu_ptr(&lttng_dynamic_len_stack, cpu)->offset = 0;
	return 0;
}
Commit	Line	Data
b7cdc182	1	/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
9f36eaed	2	*
a90917c3	3	* lttng-probes.c
02119ee5	4	*
02119ee5	5	* Holds LTTng probes registry.
17baffe2	6	*
886d51a3	7	* Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
02119ee5 MD	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/list.h>
	12	#include <linux/mutex.h>
271b6681	13	#include <linux/seq_file.h>
02119ee5	14
2df37e95	15	#include <lttng/events.h>
02119ee5	16
3c997079 MD	17	/*
	18	* probe list is protected by sessions lock.
	19	*/
	20	static LIST_HEAD(_probe_list);
	21
	22	/*
	23	* List of probes registered by not yet processed.
	24	*/
	25	static LIST_HEAD(lazy_probe_init);
02119ee5	26
3c997079	27	/*
196bfc6a	28	* lazy_nesting counter ensures we don't notify lazy probe registration
3c997079 MD	29	* fixup while we are performing the fixup. It is protected by the
	30	* sessions lock.
	31	*/
	32	static int lazy_nesting;
	33
114667d5 MD	34	DEFINE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
	35
	36	EXPORT_PER_CPU_SYMBOL_GPL(lttng_dynamic_len_stack);
	37
3c997079 MD	38	/*
	39	* Called under sessions lock.
	40	*/
85a9ca7f	41	static
437d5aa5	42	int check_event_provider(struct lttng_kernel_probe_desc *desc)
02119ee5	43	{
85a9ca7f	44	int i;
3c997079	45	size_t provider_name_len;
02119ee5	46
437d5aa5	47	provider_name_len = strnlen(desc->provider_name,
3c997079 MD	48	LTTNG_KERNEL_SYM_NAME_LEN - 1);
3c997079 MD	49	for (i = 0; i < desc->nr_events; i++) {
437d5aa5 MD	50	if (strncmp(desc->event_desc[i]->event_name,
437d5aa5 MD	51	desc->provider_name,
3c997079 MD	52	provider_name_len))
3c997079 MD	53	return 0; /* provider mismatch */
021153c0 MD	54	/*
	55	* The event needs to contain at least provider name + _ +
	56	* one or more letter.
	57	*/
437d5aa5	58	if (strlen(desc->event_desc[i]->event_name) <= provider_name_len + 1)
021153c0	59	return 0; /* provider mismatch */
437d5aa5	60	if (desc->event_desc[i]->event_name[provider_name_len] != '_')
021153c0	61	return 0; /* provider mismatch */
3c997079 MD	62	}
	63	return 1;
	64	}
	65
	66	/*
	67	* Called under sessions lock.
	68	*/
	69	static
437d5aa5	70	void lttng_lazy_probe_register(struct lttng_kernel_probe_desc *desc)
3c997079	71	{
437d5aa5	72	struct lttng_kernel_probe_desc *iter;
3c997079 MD	73	struct list_head *probe_list;
	74
	75	/*
	76	* Each provider enforce that every event name begins with the
	77	* provider name. Check this in an assertion for extra
	78	* carefulness. This ensures we cannot have duplicate event
	79	* names across providers.
	80	*/
	81	WARN_ON_ONCE(!check_event_provider(desc));
	82
	83	/*
	84	* The provider ensures there are no duplicate event names.
	85	* Duplicated TRACEPOINT_EVENT event names would generate a
	86	* compile-time error due to duplicated symbol names.
	87	*/
	88
	89	/*
437d5aa5	90	* We sort the providers by struct lttng_kernel_probe_desc pointer
3c997079 MD	91	* address.
	92	*/
	93	probe_list = &_probe_list;
	94	list_for_each_entry_reverse(iter, probe_list, head) {
	95	BUG_ON(iter == desc); /* Should never be in the list twice */
	96	if (iter < desc) {
	97	/* We belong to the location right after iter. */
	98	list_add(&desc->head, &iter->head);
	99	goto desc_added;
85a9ca7f	100	}
02119ee5	101	}
3c997079 MD	102	/* We should be added at the head of the list */
	103	list_add(&desc->head, probe_list);
	104	desc_added:
33a39a3c	105	pr_debug("LTTng: just registered probe %s containing %u events\n",
437d5aa5	106	desc->provider_name, desc->nr_events);
3c997079 MD	107	}
	108
	109	/*
	110	* Called under sessions lock.
	111	*/
	112	static
	113	void fixup_lazy_probes(void)
	114	{
437d5aa5	115	struct lttng_kernel_probe_desc iter, tmp;
3c997079 MD	116	int ret;
	117
	118	lazy_nesting++;
	119	list_for_each_entry_safe(iter, tmp,
	120	&lazy_probe_init, lazy_init_head) {
	121	lttng_lazy_probe_register(iter);
	122	iter->lazy = 0;
	123	list_del(&iter->lazy_init_head);
	124	}
	125	ret = lttng_fix_pending_events();
	126	WARN_ON_ONCE(ret);
b01155ba FD	127	ret = lttng_fix_pending_event_notifiers();
b01155ba FD	128	WARN_ON_ONCE(ret);
3c997079 MD	129	lazy_nesting--;
	130	}
	131
	132	/*
	133	* Called under sessions lock.
	134	*/
	135	struct list_head *lttng_get_probe_list_head(void)
	136	{
	137	if (!lazy_nesting && !list_empty(&lazy_probe_init))
	138	fixup_lazy_probes();
	139	return &_probe_list;
	140	}
	141
	142	static
437d5aa5	143	const struct lttng_kernel_probe_desc find_provider(const char provider)
3c997079	144	{
437d5aa5	145	struct lttng_kernel_probe_desc *iter;
3c997079 MD	146	struct list_head *probe_list;
	147
	148	probe_list = lttng_get_probe_list_head();
	149	list_for_each_entry(iter, probe_list, head) {
437d5aa5	150	if (!strcmp(iter->provider_name, provider))
3c997079 MD	151	return iter;
3c997079 MD	152	}
02119ee5 MD	153	return NULL;
	154	}
	155
437d5aa5	156	int lttng_probe_register(struct lttng_kernel_probe_desc *desc)
02119ee5	157	{
02119ee5	158	int ret = 0;
02119ee5	159
3c997079 MD	160	lttng_lock_sessions();
3c997079 MD	161
85a9ca7f	162	/*
3c997079	163	* Check if the provider has already been registered.
85a9ca7f	164	*/
437d5aa5	165	if (find_provider(desc->provider_name)) {
3c997079 MD	166	ret = -EEXIST;
3c997079 MD	167	goto end;
02119ee5	168	}
3c997079 MD	169	list_add(&desc->lazy_init_head, &lazy_probe_init);
3c997079 MD	170	desc->lazy = 1;
33a39a3c	171	pr_debug("LTTng: adding probe %s containing %u events to lazy registration list\n",
437d5aa5	172	desc->provider_name, desc->nr_events);
3c997079 MD	173	/*
	174	* If there is at least one active session, we need to register
	175	* the probe immediately, since we cannot delay event
	176	* registration because they are needed ASAP.
	177	*/
b01155ba	178	if (lttng_session_active() \|\| lttng_event_notifier_active())
3c997079	179	fixup_lazy_probes();
02119ee5	180	end:
3c997079	181	lttng_unlock_sessions();
02119ee5 MD	182	return ret;
02119ee5 MD	183	}
a90917c3	184	EXPORT_SYMBOL_GPL(lttng_probe_register);
02119ee5	185
437d5aa5	186	void lttng_probe_unregister(struct lttng_kernel_probe_desc *desc)
02119ee5	187	{
3c997079 MD	188	lttng_lock_sessions();
	189	if (!desc->lazy)
	190	list_del(&desc->head);
	191	else
	192	list_del(&desc->lazy_init_head);
437d5aa5	193	pr_debug("LTTng: just unregistered probe %s\n", desc->provider_name);
3c997079	194	lttng_unlock_sessions();
02119ee5	195	}
a90917c3	196	EXPORT_SYMBOL_GPL(lttng_probe_unregister);
02119ee5	197
3c997079 MD	198	/*
	199	* TODO: this is O(nr_probes * nb_events), could be faster.
	200	* Called with sessions lock held.
	201	*/
	202	static
437d5aa5	203	const struct lttng_kernel_event_desc find_event_desc(const char name)
3c997079	204	{
437d5aa5	205	struct lttng_kernel_probe_desc *probe_desc;
3c997079 MD	206	int i;
	207
	208	list_for_each_entry(probe_desc, &_probe_list, head) {
	209	for (i = 0; i < probe_desc->nr_events; i++) {
437d5aa5	210	if (!strcmp(probe_desc->event_desc[i]->event_name, name))
3c997079 MD	211	return probe_desc->event_desc[i];
	212	}
	213	}
	214	return NULL;
	215	}
	216
	217	/*
	218	* Called with sessions lock held.
	219	*/
437d5aa5	220	const struct lttng_kernel_event_desc lttng_event_desc_get(const char name)
02119ee5	221	{
437d5aa5	222	const struct lttng_kernel_event_desc *event_desc;
02119ee5 MD	223	int ret;
02119ee5 MD	224
0bcedee9 FD	225	event_desc = find_event_desc(name);
0bcedee9 FD	226	if (!event_desc)
c099397a	227	return NULL;
0bcedee9	228	ret = try_module_get(event_desc->owner);
02119ee5	229	WARN_ON_ONCE(!ret);
0bcedee9	230	return event_desc;
02119ee5	231	}
0bcedee9	232	EXPORT_SYMBOL_GPL(lttng_event_desc_get);
02119ee5	233
3c997079 MD	234	/*
	235	* Called with sessions lock held.
	236	*/
437d5aa5	237	void lttng_event_desc_put(const struct lttng_kernel_event_desc *event_desc)
02119ee5	238	{
0bcedee9	239	module_put(event_desc->owner);
02119ee5	240	}
0bcedee9	241	EXPORT_SYMBOL_GPL(lttng_event_desc_put);
271b6681 MD	242
	243	static
	244	void tp_list_start(struct seq_file m, loff_t *pos)
	245	{
437d5aa5	246	struct lttng_kernel_probe_desc *probe_desc;
a1031097	247	struct list_head *probe_list;
271b6681 MD	248	int iter = 0, i;
271b6681 MD	249
3c997079	250	lttng_lock_sessions();
a1031097 MD	251	probe_list = lttng_get_probe_list_head();
a1031097 MD	252	list_for_each_entry(probe_desc, probe_list, head) {
271b6681 MD	253	for (i = 0; i < probe_desc->nr_events; i++) {
271b6681 MD	254	if (iter++ >= *pos)
f7bdf4db	255	return (void *) probe_desc->event_desc[i];
271b6681 MD	256	}
	257	}
	258	/* End of list */
	259	return NULL;
	260	}
	261
	262	static
	263	void tp_list_next(struct seq_file m, void p, loff_t ppos)
	264	{
437d5aa5	265	struct lttng_kernel_probe_desc *probe_desc;
a1031097	266	struct list_head *probe_list;
271b6681 MD	267	int iter = 0, i;
	268
	269	(*ppos)++;
a1031097 MD	270	probe_list = lttng_get_probe_list_head();
a1031097 MD	271	list_for_each_entry(probe_desc, probe_list, head) {
271b6681 MD	272	for (i = 0; i < probe_desc->nr_events; i++) {
271b6681 MD	273	if (iter++ >= *ppos)
f7bdf4db	274	return (void *) probe_desc->event_desc[i];
271b6681 MD	275	}
	276	}
	277	/* End of list */
	278	return NULL;
	279	}
	280
	281	static
	282	void tp_list_stop(struct seq_file m, void p)
	283	{
3c997079	284	lttng_unlock_sessions();
271b6681 MD	285	}
	286
	287	static
	288	int tp_list_show(struct seq_file m, void p)
	289	{
437d5aa5	290	const struct lttng_kernel_event_desc *probe_desc = p;
271b6681 MD	291
271b6681 MD	292	seq_printf(m, "event { name = %s; };\n",
437d5aa5	293	probe_desc->event_name);
271b6681 MD	294	return 0;
	295	}
	296
	297	static
	298	const struct seq_operations lttng_tracepoint_list_seq_ops = {
	299	.start = tp_list_start,
	300	.next = tp_list_next,
	301	.stop = tp_list_stop,
	302	.show = tp_list_show,
	303	};
	304
	305	static
	306	int lttng_tracepoint_list_open(struct inode inode, struct file file)
	307	{
	308	return seq_open(file, &lttng_tracepoint_list_seq_ops);
	309	}
	310
	311	const struct file_operations lttng_tracepoint_list_fops = {
2e54c205	312	.owner = THIS_MODULE,
271b6681 MD	313	.open = lttng_tracepoint_list_open,
	314	.read = seq_read,
	315	.llseek = seq_lseek,
a51729c7	316	.release = seq_release,
271b6681	317	};
114667d5 MD	318
	319	int lttng_probes_init(void)
	320	{
	321	int cpu;
	322
	323	for_each_possible_cpu(cpu)
	324	per_cpu_ptr(&lttng_dynamic_len_stack, cpu)->offset = 0;
	325	return 0;
	326	}