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 | { |
0c87bcc6 | 44 | int i, mismatch = 0; |
3c997079 | 45 | size_t provider_name_len; |
02119ee5 | 46 | |
437d5aa5 | 47 | provider_name_len = strnlen(desc->provider_name, |
606828e4 | 48 | LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1); |
3c997079 | 49 | for (i = 0; i < desc->nr_events; i++) { |
021153c0 | 50 | /* |
0c87bcc6 | 51 | * The event name needs to start with provider name + _ + |
021153c0 MD |
52 | * one or more letter. |
53 | */ | |
0c87bcc6 HZ |
54 | if (strncmp(desc->event_desc[i]->event_name, desc->provider_name, provider_name_len)) |
55 | mismatch = 1; | |
56 | else if (strlen(desc->event_desc[i]->event_name) <= provider_name_len + 1) | |
57 | mismatch = 1; | |
58 | else if (desc->event_desc[i]->event_name[provider_name_len] != '_') | |
59 | mismatch = 1; | |
60 | ||
61 | if (mismatch) { | |
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); | |
67 | return 0; | |
68 | } | |
3c997079 MD |
69 | } |
70 | return 1; | |
71 | } | |
72 | ||
73 | /* | |
74 | * Called under sessions lock. | |
75 | */ | |
76 | static | |
437d5aa5 | 77 | void lttng_lazy_probe_register(struct lttng_kernel_probe_desc *desc) |
3c997079 | 78 | { |
437d5aa5 | 79 | struct lttng_kernel_probe_desc *iter; |
3c997079 MD |
80 | struct list_head *probe_list; |
81 | ||
82 | /* | |
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. | |
87 | */ | |
88 | WARN_ON_ONCE(!check_event_provider(desc)); | |
89 | ||
90 | /* | |
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. | |
94 | */ | |
95 | ||
96 | /* | |
437d5aa5 | 97 | * We sort the providers by struct lttng_kernel_probe_desc pointer |
3c997079 MD |
98 | * address. |
99 | */ | |
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 */ | |
103 | if (iter < desc) { | |
104 | /* We belong to the location right after iter. */ | |
105 | list_add(&desc->head, &iter->head); | |
106 | goto desc_added; | |
85a9ca7f | 107 | } |
02119ee5 | 108 | } |
3c997079 MD |
109 | /* We should be added at the head of the list */ |
110 | list_add(&desc->head, probe_list); | |
111 | desc_added: | |
33a39a3c | 112 | pr_debug("LTTng: just registered probe %s containing %u events\n", |
437d5aa5 | 113 | desc->provider_name, desc->nr_events); |
3c997079 MD |
114 | } |
115 | ||
116 | /* | |
117 | * Called under sessions lock. | |
118 | */ | |
119 | static | |
120 | void fixup_lazy_probes(void) | |
121 | { | |
437d5aa5 | 122 | struct lttng_kernel_probe_desc *iter, *tmp; |
3c997079 MD |
123 | int ret; |
124 | ||
125 | lazy_nesting++; | |
126 | list_for_each_entry_safe(iter, tmp, | |
127 | &lazy_probe_init, lazy_init_head) { | |
128 | lttng_lazy_probe_register(iter); | |
129 | iter->lazy = 0; | |
130 | list_del(&iter->lazy_init_head); | |
131 | } | |
132 | ret = lttng_fix_pending_events(); | |
133 | WARN_ON_ONCE(ret); | |
b01155ba FD |
134 | ret = lttng_fix_pending_event_notifiers(); |
135 | WARN_ON_ONCE(ret); | |
3c997079 MD |
136 | lazy_nesting--; |
137 | } | |
138 | ||
139 | /* | |
140 | * Called under sessions lock. | |
141 | */ | |
142 | struct list_head *lttng_get_probe_list_head(void) | |
143 | { | |
144 | if (!lazy_nesting && !list_empty(&lazy_probe_init)) | |
145 | fixup_lazy_probes(); | |
146 | return &_probe_list; | |
147 | } | |
148 | ||
149 | static | |
437d5aa5 | 150 | const struct lttng_kernel_probe_desc *find_provider(const char *provider) |
3c997079 | 151 | { |
437d5aa5 | 152 | struct lttng_kernel_probe_desc *iter; |
3c997079 MD |
153 | struct list_head *probe_list; |
154 | ||
155 | probe_list = lttng_get_probe_list_head(); | |
156 | list_for_each_entry(iter, probe_list, head) { | |
437d5aa5 | 157 | if (!strcmp(iter->provider_name, provider)) |
3c997079 MD |
158 | return iter; |
159 | } | |
02119ee5 MD |
160 | return NULL; |
161 | } | |
162 | ||
437d5aa5 | 163 | int lttng_probe_register(struct lttng_kernel_probe_desc *desc) |
02119ee5 | 164 | { |
02119ee5 | 165 | int ret = 0; |
02119ee5 | 166 | |
3c997079 MD |
167 | lttng_lock_sessions(); |
168 | ||
85a9ca7f | 169 | /* |
3c997079 | 170 | * Check if the provider has already been registered. |
85a9ca7f | 171 | */ |
437d5aa5 | 172 | if (find_provider(desc->provider_name)) { |
3c997079 MD |
173 | ret = -EEXIST; |
174 | goto end; | |
02119ee5 | 175 | } |
3c997079 MD |
176 | list_add(&desc->lazy_init_head, &lazy_probe_init); |
177 | desc->lazy = 1; | |
33a39a3c | 178 | pr_debug("LTTng: adding probe %s containing %u events to lazy registration list\n", |
437d5aa5 | 179 | desc->provider_name, desc->nr_events); |
3c997079 MD |
180 | /* |
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. | |
184 | */ | |
b01155ba | 185 | if (lttng_session_active() || lttng_event_notifier_active()) |
3c997079 | 186 | fixup_lazy_probes(); |
02119ee5 | 187 | end: |
3c997079 | 188 | lttng_unlock_sessions(); |
02119ee5 MD |
189 | return ret; |
190 | } | |
a90917c3 | 191 | EXPORT_SYMBOL_GPL(lttng_probe_register); |
02119ee5 | 192 | |
437d5aa5 | 193 | void lttng_probe_unregister(struct lttng_kernel_probe_desc *desc) |
02119ee5 | 194 | { |
3c997079 MD |
195 | lttng_lock_sessions(); |
196 | if (!desc->lazy) | |
197 | list_del(&desc->head); | |
198 | else | |
199 | list_del(&desc->lazy_init_head); | |
437d5aa5 | 200 | pr_debug("LTTng: just unregistered probe %s\n", desc->provider_name); |
3c997079 | 201 | lttng_unlock_sessions(); |
02119ee5 | 202 | } |
a90917c3 | 203 | EXPORT_SYMBOL_GPL(lttng_probe_unregister); |
02119ee5 | 204 | |
3c997079 MD |
205 | /* |
206 | * TODO: this is O(nr_probes * nb_events), could be faster. | |
207 | * Called with sessions lock held. | |
208 | */ | |
209 | static | |
437d5aa5 | 210 | const struct lttng_kernel_event_desc *find_event_desc(const char *name) |
3c997079 | 211 | { |
437d5aa5 | 212 | struct lttng_kernel_probe_desc *probe_desc; |
3c997079 MD |
213 | int i; |
214 | ||
215 | list_for_each_entry(probe_desc, &_probe_list, head) { | |
216 | for (i = 0; i < probe_desc->nr_events; i++) { | |
437d5aa5 | 217 | if (!strcmp(probe_desc->event_desc[i]->event_name, name)) |
3c997079 MD |
218 | return probe_desc->event_desc[i]; |
219 | } | |
220 | } | |
221 | return NULL; | |
222 | } | |
223 | ||
224 | /* | |
225 | * Called with sessions lock held. | |
226 | */ | |
437d5aa5 | 227 | const struct lttng_kernel_event_desc *lttng_event_desc_get(const char *name) |
02119ee5 | 228 | { |
437d5aa5 | 229 | const struct lttng_kernel_event_desc *event_desc; |
02119ee5 MD |
230 | int ret; |
231 | ||
0bcedee9 FD |
232 | event_desc = find_event_desc(name); |
233 | if (!event_desc) | |
c099397a | 234 | return NULL; |
0bcedee9 | 235 | ret = try_module_get(event_desc->owner); |
02119ee5 | 236 | WARN_ON_ONCE(!ret); |
0bcedee9 | 237 | return event_desc; |
02119ee5 | 238 | } |
0bcedee9 | 239 | EXPORT_SYMBOL_GPL(lttng_event_desc_get); |
02119ee5 | 240 | |
3c997079 MD |
241 | /* |
242 | * Called with sessions lock held. | |
243 | */ | |
437d5aa5 | 244 | void lttng_event_desc_put(const struct lttng_kernel_event_desc *event_desc) |
02119ee5 | 245 | { |
0bcedee9 | 246 | module_put(event_desc->owner); |
02119ee5 | 247 | } |
0bcedee9 | 248 | EXPORT_SYMBOL_GPL(lttng_event_desc_put); |
271b6681 MD |
249 | |
250 | static | |
251 | void *tp_list_start(struct seq_file *m, loff_t *pos) | |
252 | { | |
437d5aa5 | 253 | struct lttng_kernel_probe_desc *probe_desc; |
a1031097 | 254 | struct list_head *probe_list; |
271b6681 MD |
255 | int iter = 0, i; |
256 | ||
3c997079 | 257 | lttng_lock_sessions(); |
a1031097 MD |
258 | probe_list = lttng_get_probe_list_head(); |
259 | list_for_each_entry(probe_desc, probe_list, head) { | |
271b6681 MD |
260 | for (i = 0; i < probe_desc->nr_events; i++) { |
261 | if (iter++ >= *pos) | |
f7bdf4db | 262 | return (void *) probe_desc->event_desc[i]; |
271b6681 MD |
263 | } |
264 | } | |
265 | /* End of list */ | |
266 | return NULL; | |
267 | } | |
268 | ||
269 | static | |
270 | void *tp_list_next(struct seq_file *m, void *p, loff_t *ppos) | |
271 | { | |
437d5aa5 | 272 | struct lttng_kernel_probe_desc *probe_desc; |
a1031097 | 273 | struct list_head *probe_list; |
271b6681 MD |
274 | int iter = 0, i; |
275 | ||
276 | (*ppos)++; | |
a1031097 MD |
277 | probe_list = lttng_get_probe_list_head(); |
278 | list_for_each_entry(probe_desc, probe_list, head) { | |
271b6681 MD |
279 | for (i = 0; i < probe_desc->nr_events; i++) { |
280 | if (iter++ >= *ppos) | |
f7bdf4db | 281 | return (void *) probe_desc->event_desc[i]; |
271b6681 MD |
282 | } |
283 | } | |
284 | /* End of list */ | |
285 | return NULL; | |
286 | } | |
287 | ||
288 | static | |
289 | void tp_list_stop(struct seq_file *m, void *p) | |
290 | { | |
3c997079 | 291 | lttng_unlock_sessions(); |
271b6681 MD |
292 | } |
293 | ||
294 | static | |
295 | int tp_list_show(struct seq_file *m, void *p) | |
296 | { | |
437d5aa5 | 297 | const struct lttng_kernel_event_desc *probe_desc = p; |
271b6681 MD |
298 | |
299 | seq_printf(m, "event { name = %s; };\n", | |
437d5aa5 | 300 | probe_desc->event_name); |
271b6681 MD |
301 | return 0; |
302 | } | |
303 | ||
304 | static | |
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, | |
310 | }; | |
311 | ||
312 | static | |
313 | int lttng_tracepoint_list_open(struct inode *inode, struct file *file) | |
314 | { | |
315 | return seq_open(file, <tng_tracepoint_list_seq_ops); | |
316 | } | |
317 | ||
318 | const struct file_operations lttng_tracepoint_list_fops = { | |
2e54c205 | 319 | .owner = THIS_MODULE, |
271b6681 MD |
320 | .open = lttng_tracepoint_list_open, |
321 | .read = seq_read, | |
322 | .llseek = seq_lseek, | |
a51729c7 | 323 | .release = seq_release, |
271b6681 | 324 | }; |
114667d5 MD |
325 | |
326 | int lttng_probes_init(void) | |
327 | { | |
328 | int cpu; | |
329 | ||
330 | for_each_possible_cpu(cpu) | |
331 | per_cpu_ptr(<tng_dynamic_len_stack, cpu)->offset = 0; | |
332 | return 0; | |
333 | } |