1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
5 * Holds LTTng probes registry.
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 #include <linux/module.h>
11 #include <linux/list.h>
12 #include <linux/mutex.h>
13 #include <linux/seq_file.h>
15 #include <lttng/events.h>
18 * probe list is protected by sessions lock.
20 static LIST_HEAD(_probe_list
);
23 * List of probes registered by not yet processed.
25 static LIST_HEAD(lazy_probe_init
);
28 * lazy_nesting counter ensures we don't notify lazy probe registration
29 * fixup while we are performing the fixup. It is protected by the
32 static int lazy_nesting
;
34 DEFINE_PER_CPU(struct lttng_dynamic_len_stack
, lttng_dynamic_len_stack
);
36 EXPORT_PER_CPU_SYMBOL_GPL(lttng_dynamic_len_stack
);
39 * Called under sessions lock.
42 int check_event_provider(struct lttng_kernel_probe_desc
*desc
)
45 size_t provider_name_len
;
47 provider_name_len
= strnlen(desc
->provider_name
,
48 LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1);
49 for (i
= 0; i
< desc
->nr_events
; i
++) {
51 * The event name needs to start with provider name + _ +
54 if (strncmp(desc
->event_desc
[i
]->event_name
, desc
->provider_name
, provider_name_len
))
56 else if (strlen(desc
->event_desc
[i
]->event_name
) <= provider_name_len
+ 1)
58 else if (desc
->event_desc
[i
]->event_name
[provider_name_len
] != '_')
62 printk(KERN_WARNING
"LTTng: event provider mismatch: "
63 "The event name needs to start with provider "
64 "name + _ + one or more letter, "
65 "provider: %s, event name: %s\n",
66 desc
->provider_name
, desc
->event_desc
[i
]->event_name
);
74 * Called under sessions lock.
77 void lttng_lazy_probe_register(struct lttng_kernel_probe_desc
*desc
)
79 struct lttng_kernel_probe_desc
*iter
;
80 struct list_head
*probe_list
;
83 * Each provider enforce that every event name begins with the
84 * provider name. Check this in an assertion for extra
85 * carefulness. This ensures we cannot have duplicate event
86 * names across providers.
88 WARN_ON_ONCE(!check_event_provider(desc
));
91 * The provider ensures there are no duplicate event names.
92 * Duplicated TRACEPOINT_EVENT event names would generate a
93 * compile-time error due to duplicated symbol names.
97 * We sort the providers by struct lttng_kernel_probe_desc pointer
100 probe_list
= &_probe_list
;
101 list_for_each_entry_reverse(iter
, probe_list
, head
) {
102 BUG_ON(iter
== desc
); /* Should never be in the list twice */
104 /* We belong to the location right after iter. */
105 list_add(&desc
->head
, &iter
->head
);
109 /* We should be added at the head of the list */
110 list_add(&desc
->head
, probe_list
);
112 pr_debug("LTTng: just registered probe %s containing %u events\n",
113 desc
->provider_name
, desc
->nr_events
);
117 * Called under sessions lock.
120 void fixup_lazy_probes(void)
122 struct lttng_kernel_probe_desc
*iter
, *tmp
;
126 list_for_each_entry_safe(iter
, tmp
,
127 &lazy_probe_init
, lazy_init_head
) {
128 lttng_lazy_probe_register(iter
);
130 list_del(&iter
->lazy_init_head
);
132 ret
= lttng_fix_pending_events();
134 ret
= lttng_fix_pending_event_notifiers();
140 * Called under sessions lock.
142 struct list_head
*lttng_get_probe_list_head(void)
144 if (!lazy_nesting
&& !list_empty(&lazy_probe_init
))
150 const struct lttng_kernel_probe_desc
*find_provider(const char *provider
)
152 struct lttng_kernel_probe_desc
*iter
;
153 struct list_head
*probe_list
;
155 probe_list
= lttng_get_probe_list_head();
156 list_for_each_entry(iter
, probe_list
, head
) {
157 if (!strcmp(iter
->provider_name
, provider
))
163 int lttng_probe_register(struct lttng_kernel_probe_desc
*desc
)
167 lttng_lock_sessions();
170 * Check if the provider has already been registered.
172 if (find_provider(desc
->provider_name
)) {
176 list_add(&desc
->lazy_init_head
, &lazy_probe_init
);
178 pr_debug("LTTng: adding probe %s containing %u events to lazy registration list\n",
179 desc
->provider_name
, desc
->nr_events
);
181 * If there is at least one active session, we need to register
182 * the probe immediately, since we cannot delay event
183 * registration because they are needed ASAP.
185 if (lttng_session_active() || lttng_event_notifier_active())
188 lttng_unlock_sessions();
191 EXPORT_SYMBOL_GPL(lttng_probe_register
);
193 void lttng_probe_unregister(struct lttng_kernel_probe_desc
*desc
)
195 lttng_lock_sessions();
197 list_del(&desc
->head
);
199 list_del(&desc
->lazy_init_head
);
200 pr_debug("LTTng: just unregistered probe %s\n", desc
->provider_name
);
201 lttng_unlock_sessions();
203 EXPORT_SYMBOL_GPL(lttng_probe_unregister
);
206 * TODO: this is O(nr_probes * nb_events), could be faster.
207 * Called with sessions lock held.
210 const struct lttng_kernel_event_desc
*find_event_desc(const char *name
)
212 struct lttng_kernel_probe_desc
*probe_desc
;
215 list_for_each_entry(probe_desc
, &_probe_list
, head
) {
216 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
217 if (!strcmp(probe_desc
->event_desc
[i
]->event_name
, name
))
218 return probe_desc
->event_desc
[i
];
225 * Called with sessions lock held.
227 const struct lttng_kernel_event_desc
*lttng_event_desc_get(const char *name
)
229 const struct lttng_kernel_event_desc
*event_desc
;
232 event_desc
= find_event_desc(name
);
235 ret
= try_module_get(event_desc
->owner
);
239 EXPORT_SYMBOL_GPL(lttng_event_desc_get
);
242 * Called with sessions lock held.
244 void lttng_event_desc_put(const struct lttng_kernel_event_desc
*event_desc
)
246 module_put(event_desc
->owner
);
248 EXPORT_SYMBOL_GPL(lttng_event_desc_put
);
251 void *tp_list_start(struct seq_file
*m
, loff_t
*pos
)
253 struct lttng_kernel_probe_desc
*probe_desc
;
254 struct list_head
*probe_list
;
257 lttng_lock_sessions();
258 probe_list
= lttng_get_probe_list_head();
259 list_for_each_entry(probe_desc
, probe_list
, head
) {
260 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
262 return (void *) probe_desc
->event_desc
[i
];
270 void *tp_list_next(struct seq_file
*m
, void *p
, loff_t
*ppos
)
272 struct lttng_kernel_probe_desc
*probe_desc
;
273 struct list_head
*probe_list
;
277 probe_list
= lttng_get_probe_list_head();
278 list_for_each_entry(probe_desc
, probe_list
, head
) {
279 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
281 return (void *) probe_desc
->event_desc
[i
];
289 void tp_list_stop(struct seq_file
*m
, void *p
)
291 lttng_unlock_sessions();
295 int tp_list_show(struct seq_file
*m
, void *p
)
297 const struct lttng_kernel_event_desc
*probe_desc
= p
;
299 seq_printf(m
, "event { name = %s; };\n",
300 probe_desc
->event_name
);
305 const struct seq_operations lttng_tracepoint_list_seq_ops
= {
306 .start
= tp_list_start
,
307 .next
= tp_list_next
,
308 .stop
= tp_list_stop
,
309 .show
= tp_list_show
,
313 int lttng_tracepoint_list_open(struct inode
*inode
, struct file
*file
)
315 return seq_open(file
, <tng_tracepoint_list_seq_ops
);
318 const struct file_operations lttng_tracepoint_list_fops
= {
319 .owner
= THIS_MODULE
,
320 .open
= lttng_tracepoint_list_open
,
323 .release
= seq_release
,
326 int lttng_probes_init(void)
330 for_each_possible_cpu(cpu
)
331 per_cpu_ptr(<tng_dynamic_len_stack
, cpu
)->offset
= 0;