Commit | Line | Data |
---|---|---|
ce5aef0b | 1 | /* |
c0c0989a | 2 | * SPDX-License-Identifier: LGPL-2.1-only |
ce5aef0b | 3 | * |
c0c0989a | 4 | * Copyright 2010-2012 (C) Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
e92f3e28 | 5 | * |
c0c0989a | 6 | * Holds LTTng probes registry. |
ce5aef0b MD |
7 | */ |
8 | ||
3fbec7dc | 9 | #define _LGPL_SOURCE |
8d8a24c8 MD |
10 | #include <string.h> |
11 | #include <errno.h> | |
12 | #include <urcu/list.h> | |
1f18504e | 13 | #include <urcu/hlist.h> |
4318ae1b | 14 | #include <lttng/ust-events.h> |
902e1379 | 15 | #include <lttng/tracepoint.h> |
d8de1354 | 16 | #include "tracepoint-internal.h" |
a3bb4b27 | 17 | #include <assert.h> |
c8fcf224 | 18 | #include <helper.h> |
48740cab | 19 | #include <ctype.h> |
ce5aef0b | 20 | |
7dd08bec | 21 | #include "lttng-tracer-core.h" |
1f18504e MD |
22 | #include "jhash.h" |
23 | #include "error.h" | |
d8d2416d | 24 | #include "ust-events-internal.h" |
8165c8da MD |
25 | |
26 | /* | |
17dfb34b | 27 | * probe list is protected by ust_lock()/ust_unlock(). |
8165c8da | 28 | */ |
ac69b35b | 29 | static CDS_LIST_HEAD(_probe_list); |
e58095ef | 30 | |
6715d7d1 MD |
31 | /* |
32 | * List of probes registered by not yet processed. | |
33 | */ | |
34 | static CDS_LIST_HEAD(lazy_probe_init); | |
df854e41 | 35 | |
6715d7d1 MD |
36 | /* |
37 | * lazy_nesting counter ensures we don't trigger lazy probe registration | |
38 | * fixup while we are performing the fixup. It is protected by the ust | |
39 | * mutex. | |
40 | */ | |
41 | static int lazy_nesting; | |
df854e41 | 42 | |
6715d7d1 MD |
43 | /* |
44 | * Called under ust lock. | |
45 | */ | |
ce5aef0b | 46 | static |
48205d60 | 47 | int check_event_provider(struct lttng_probe_desc *desc) |
ce5aef0b | 48 | { |
ce5aef0b | 49 | int i; |
48205d60 | 50 | size_t provider_name_len; |
ce5aef0b | 51 | |
48205d60 MD |
52 | provider_name_len = strnlen(desc->provider, |
53 | LTTNG_UST_SYM_NAME_LEN - 1); | |
54 | for (i = 0; i < desc->nr_events; i++) { | |
55 | if (strncmp(desc->event_desc[i]->name, | |
56 | desc->provider, | |
57 | provider_name_len)) | |
58 | return 0; /* provider mismatch */ | |
ce5aef0b | 59 | } |
48205d60 | 60 | return 1; |
ce5aef0b MD |
61 | } |
62 | ||
6715d7d1 MD |
63 | /* |
64 | * Called under ust lock. | |
65 | */ | |
66 | static | |
67 | void lttng_lazy_probe_register(struct lttng_probe_desc *desc) | |
ce5aef0b | 68 | { |
df854e41 | 69 | struct lttng_probe_desc *iter; |
ac69b35b | 70 | struct cds_list_head *probe_list; |
48205d60 | 71 | |
ce5aef0b | 72 | /* |
48205d60 MD |
73 | * Each provider enforce that every event name begins with the |
74 | * provider name. Check this in an assertion for extra | |
75 | * carefulness. This ensures we cannot have duplicate event | |
76 | * names across providers. | |
77 | */ | |
78 | assert(check_event_provider(desc)); | |
79 | ||
80 | /* | |
81 | * The provider ensures there are no duplicate event names. | |
82 | * Duplicated TRACEPOINT_EVENT event names would generate a | |
83 | * compile-time error due to duplicated symbol names. | |
ce5aef0b | 84 | */ |
df854e41 MD |
85 | |
86 | /* | |
87 | * We sort the providers by struct lttng_probe_desc pointer | |
88 | * address. | |
89 | */ | |
6715d7d1 | 90 | probe_list = &_probe_list; |
ac69b35b | 91 | cds_list_for_each_entry_reverse(iter, probe_list, head) { |
df854e41 MD |
92 | BUG_ON(iter == desc); /* Should never be in the list twice */ |
93 | if (iter < desc) { | |
94 | /* We belong to the location right after iter. */ | |
95 | cds_list_add(&desc->head, &iter->head); | |
96 | goto desc_added; | |
97 | } | |
98 | } | |
99 | /* We should be added at the head of the list */ | |
ac69b35b | 100 | cds_list_add(&desc->head, probe_list); |
df854e41 | 101 | desc_added: |
e81a53af MD |
102 | DBG("just registered probe %s containing %u events", |
103 | desc->provider, desc->nr_events); | |
6715d7d1 MD |
104 | } |
105 | ||
106 | /* | |
107 | * Called under ust lock. | |
108 | */ | |
109 | static | |
110 | void fixup_lazy_probes(void) | |
111 | { | |
112 | struct lttng_probe_desc *iter, *tmp; | |
5f733922 | 113 | int ret; |
6715d7d1 MD |
114 | |
115 | lazy_nesting++; | |
116 | cds_list_for_each_entry_safe(iter, tmp, | |
117 | &lazy_probe_init, lazy_init_head) { | |
118 | lttng_lazy_probe_register(iter); | |
119 | iter->lazy = 0; | |
120 | cds_list_del(&iter->lazy_init_head); | |
121 | } | |
5f733922 MD |
122 | ret = lttng_fix_pending_events(); |
123 | assert(!ret); | |
6715d7d1 MD |
124 | lazy_nesting--; |
125 | } | |
126 | ||
127 | /* | |
128 | * Called under ust lock. | |
129 | */ | |
130 | struct cds_list_head *lttng_get_probe_list_head(void) | |
131 | { | |
132 | if (!lazy_nesting && !cds_list_empty(&lazy_probe_init)) | |
133 | fixup_lazy_probes(); | |
134 | return &_probe_list; | |
135 | } | |
136 | ||
71d31690 MD |
137 | static |
138 | int check_provider_version(struct lttng_probe_desc *desc) | |
139 | { | |
140 | /* | |
141 | * Check tracepoint provider version compatibility. | |
142 | */ | |
143 | if (desc->major <= LTTNG_UST_PROVIDER_MAJOR) { | |
144 | DBG("Provider \"%s\" accepted, version %u.%u is compatible " | |
145 | "with LTTng UST provider version %u.%u.", | |
146 | desc->provider, desc->major, desc->minor, | |
147 | LTTNG_UST_PROVIDER_MAJOR, | |
148 | LTTNG_UST_PROVIDER_MINOR); | |
149 | if (desc->major < LTTNG_UST_PROVIDER_MAJOR) { | |
150 | DBG("However, some LTTng UST features might not be " | |
151 | "available for this provider unless it is " | |
152 | "recompiled against a more recent LTTng UST."); | |
153 | } | |
154 | return 1; /* accept */ | |
155 | } else { | |
156 | ERR("Provider \"%s\" rejected, version %u.%u is incompatible " | |
157 | "with LTTng UST provider version %u.%u. Please upgrade " | |
158 | "LTTng UST.", | |
159 | desc->provider, desc->major, desc->minor, | |
160 | LTTNG_UST_PROVIDER_MAJOR, | |
161 | LTTNG_UST_PROVIDER_MINOR); | |
162 | return 0; /* reject */ | |
163 | } | |
164 | } | |
165 | ||
166 | ||
6715d7d1 MD |
167 | int lttng_probe_register(struct lttng_probe_desc *desc) |
168 | { | |
169 | int ret = 0; | |
170 | ||
c362addf MD |
171 | lttng_ust_fixup_tls(); |
172 | ||
71d31690 MD |
173 | /* |
174 | * If version mismatch, don't register, but don't trigger assert | |
175 | * on caller. The version check just prints an error. | |
176 | */ | |
177 | if (!check_provider_version(desc)) | |
178 | return 0; | |
179 | ||
3327ac33 | 180 | ust_lock_nocheck(); |
6715d7d1 | 181 | |
6715d7d1 MD |
182 | cds_list_add(&desc->lazy_init_head, &lazy_probe_init); |
183 | desc->lazy = 1; | |
184 | DBG("adding probe %s containing %u events to lazy registration list", | |
185 | desc->provider, desc->nr_events); | |
186 | /* | |
187 | * If there is at least one active session, we need to register | |
188 | * the probe immediately, since we cannot delay event | |
189 | * registration because they are needed ASAP. | |
190 | */ | |
191 | if (lttng_session_active()) | |
192 | fixup_lazy_probes(); | |
0fdd0b89 | 193 | |
d8d2416d FD |
194 | lttng_fix_pending_event_notifiers(); |
195 | ||
17dfb34b | 196 | ust_unlock(); |
ce5aef0b MD |
197 | return ret; |
198 | } | |
ce5aef0b | 199 | |
7dd08bec | 200 | void lttng_probe_unregister(struct lttng_probe_desc *desc) |
ce5aef0b | 201 | { |
c362addf MD |
202 | lttng_ust_fixup_tls(); |
203 | ||
71d31690 MD |
204 | if (!check_provider_version(desc)) |
205 | return; | |
206 | ||
3327ac33 | 207 | ust_lock_nocheck(); |
6715d7d1 MD |
208 | if (!desc->lazy) |
209 | cds_list_del(&desc->head); | |
210 | else | |
211 | cds_list_del(&desc->lazy_init_head); | |
2c05c691 FD |
212 | |
213 | lttng_probe_provider_unregister_events(desc); | |
214 | DBG("just unregistered probes of provider %s", desc->provider); | |
215 | ||
17dfb34b | 216 | ust_unlock(); |
ce5aef0b | 217 | } |
ce5aef0b | 218 | |
7dd08bec | 219 | void lttng_probes_prune_event_list(struct lttng_ust_tracepoint_list *list) |
c8fcf224 MD |
220 | { |
221 | struct tp_list_entry *list_entry, *tmp; | |
222 | ||
223 | cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { | |
224 | cds_list_del(&list_entry->head); | |
225 | free(list_entry); | |
226 | } | |
227 | } | |
228 | ||
229 | /* | |
230 | * called with UST lock held. | |
231 | */ | |
7dd08bec | 232 | int lttng_probes_get_event_list(struct lttng_ust_tracepoint_list *list) |
c8fcf224 MD |
233 | { |
234 | struct lttng_probe_desc *probe_desc; | |
235 | int i; | |
ac69b35b | 236 | struct cds_list_head *probe_list; |
c8fcf224 | 237 | |
ac69b35b | 238 | probe_list = lttng_get_probe_list_head(); |
c8fcf224 | 239 | CDS_INIT_LIST_HEAD(&list->head); |
ac69b35b | 240 | cds_list_for_each_entry(probe_desc, probe_list, head) { |
c8fcf224 MD |
241 | for (i = 0; i < probe_desc->nr_events; i++) { |
242 | struct tp_list_entry *list_entry; | |
243 | ||
244 | list_entry = zmalloc(sizeof(*list_entry)); | |
245 | if (!list_entry) | |
246 | goto err_nomem; | |
247 | cds_list_add(&list_entry->head, &list->head); | |
248 | strncpy(list_entry->tp.name, | |
249 | probe_desc->event_desc[i]->name, | |
250 | LTTNG_UST_SYM_NAME_LEN); | |
251 | list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
252 | if (!probe_desc->event_desc[i]->loglevel) { | |
882a56d7 | 253 | list_entry->tp.loglevel = TRACE_DEFAULT; |
c8fcf224 | 254 | } else { |
882a56d7 | 255 | list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel); |
c8fcf224 MD |
256 | } |
257 | } | |
258 | } | |
259 | if (cds_list_empty(&list->head)) | |
260 | list->iter = NULL; | |
261 | else | |
262 | list->iter = | |
263 | cds_list_first_entry(&list->head, struct tp_list_entry, head); | |
264 | return 0; | |
265 | ||
266 | err_nomem: | |
7dd08bec | 267 | lttng_probes_prune_event_list(list); |
c8fcf224 MD |
268 | return -ENOMEM; |
269 | } | |
270 | ||
271 | /* | |
272 | * Return current iteration position, advance internal iterator to next. | |
273 | * Return NULL if end of list. | |
274 | */ | |
275 | struct lttng_ust_tracepoint_iter * | |
276 | lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list) | |
277 | { | |
278 | struct tp_list_entry *entry; | |
279 | ||
280 | if (!list->iter) | |
281 | return NULL; | |
282 | entry = list->iter; | |
283 | if (entry->head.next == &list->head) | |
284 | list->iter = NULL; | |
285 | else | |
286 | list->iter = cds_list_entry(entry->head.next, | |
287 | struct tp_list_entry, head); | |
288 | return &entry->tp; | |
289 | } | |
1f18504e | 290 | |
7dd08bec | 291 | void lttng_probes_prune_field_list(struct lttng_ust_field_list *list) |
06d4f27e MD |
292 | { |
293 | struct tp_field_list_entry *list_entry, *tmp; | |
294 | ||
295 | cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { | |
296 | cds_list_del(&list_entry->head); | |
297 | free(list_entry); | |
298 | } | |
299 | } | |
300 | ||
301 | /* | |
302 | * called with UST lock held. | |
303 | */ | |
7dd08bec | 304 | int lttng_probes_get_field_list(struct lttng_ust_field_list *list) |
06d4f27e MD |
305 | { |
306 | struct lttng_probe_desc *probe_desc; | |
307 | int i; | |
ac69b35b | 308 | struct cds_list_head *probe_list; |
06d4f27e | 309 | |
ac69b35b | 310 | probe_list = lttng_get_probe_list_head(); |
06d4f27e | 311 | CDS_INIT_LIST_HEAD(&list->head); |
ac69b35b | 312 | cds_list_for_each_entry(probe_desc, probe_list, head) { |
06d4f27e MD |
313 | for (i = 0; i < probe_desc->nr_events; i++) { |
314 | const struct lttng_event_desc *event_desc = | |
315 | probe_desc->event_desc[i]; | |
316 | int j; | |
317 | ||
26329f26 MD |
318 | if (event_desc->nr_fields == 0) { |
319 | /* Events without fields. */ | |
320 | struct tp_field_list_entry *list_entry; | |
321 | ||
322 | list_entry = zmalloc(sizeof(*list_entry)); | |
323 | if (!list_entry) | |
324 | goto err_nomem; | |
325 | cds_list_add(&list_entry->head, &list->head); | |
326 | strncpy(list_entry->field.event_name, | |
327 | event_desc->name, | |
328 | LTTNG_UST_SYM_NAME_LEN); | |
329 | list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
330 | list_entry->field.field_name[0] = '\0'; | |
331 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
332 | if (!event_desc->loglevel) { | |
333 | list_entry->field.loglevel = TRACE_DEFAULT; | |
334 | } else { | |
335 | list_entry->field.loglevel = *(*event_desc->loglevel); | |
336 | } | |
337 | list_entry->field.nowrite = 1; | |
338 | } | |
339 | ||
06d4f27e MD |
340 | for (j = 0; j < event_desc->nr_fields; j++) { |
341 | const struct lttng_event_field *event_field = | |
342 | &event_desc->fields[j]; | |
343 | struct tp_field_list_entry *list_entry; | |
344 | ||
345 | list_entry = zmalloc(sizeof(*list_entry)); | |
346 | if (!list_entry) | |
347 | goto err_nomem; | |
348 | cds_list_add(&list_entry->head, &list->head); | |
349 | strncpy(list_entry->field.event_name, | |
350 | event_desc->name, | |
351 | LTTNG_UST_SYM_NAME_LEN); | |
352 | list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
353 | strncpy(list_entry->field.field_name, | |
354 | event_field->name, | |
355 | LTTNG_UST_SYM_NAME_LEN); | |
356 | list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
40003310 MD |
357 | switch (event_field->type.atype) { |
358 | case atype_integer: | |
359 | list_entry->field.type = LTTNG_UST_FIELD_INTEGER; | |
360 | break; | |
361 | case atype_string: | |
362 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
363 | break; | |
364 | case atype_array: | |
218deb69 MD |
365 | if (event_field->type.u.legacy.array.elem_type.atype != atype_integer |
366 | || event_field->type.u.legacy.array.elem_type.u.basic.integer.encoding == lttng_encode_none) | |
367 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
368 | else | |
369 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
370 | break; | |
371 | case atype_array_nestable: | |
372 | if (event_field->type.u.array_nestable.elem_type->atype != atype_integer | |
373 | || event_field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) | |
40003310 MD |
374 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; |
375 | else | |
376 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
377 | break; | |
378 | case atype_sequence: | |
218deb69 MD |
379 | if (event_field->type.u.legacy.sequence.elem_type.atype != atype_integer |
380 | || event_field->type.u.legacy.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) | |
381 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
382 | else | |
383 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
384 | break; | |
385 | case atype_sequence_nestable: | |
386 | if (event_field->type.u.sequence_nestable.elem_type->atype != atype_integer | |
387 | || event_field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) | |
40003310 MD |
388 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; |
389 | else | |
390 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
391 | break; | |
392 | case atype_float: | |
393 | list_entry->field.type = LTTNG_UST_FIELD_FLOAT; | |
394 | break; | |
218deb69 MD |
395 | case atype_enum: /* Fall-through */ |
396 | case atype_enum_nestable: | |
40003310 MD |
397 | list_entry->field.type = LTTNG_UST_FIELD_ENUM; |
398 | break; | |
399 | default: | |
400 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
401 | } | |
06d4f27e MD |
402 | if (!event_desc->loglevel) { |
403 | list_entry->field.loglevel = TRACE_DEFAULT; | |
404 | } else { | |
405 | list_entry->field.loglevel = *(*event_desc->loglevel); | |
406 | } | |
180901e6 | 407 | list_entry->field.nowrite = event_field->nowrite; |
06d4f27e MD |
408 | } |
409 | } | |
410 | } | |
411 | if (cds_list_empty(&list->head)) | |
412 | list->iter = NULL; | |
413 | else | |
414 | list->iter = | |
415 | cds_list_first_entry(&list->head, | |
416 | struct tp_field_list_entry, head); | |
417 | return 0; | |
418 | ||
419 | err_nomem: | |
7dd08bec | 420 | lttng_probes_prune_field_list(list); |
06d4f27e MD |
421 | return -ENOMEM; |
422 | } | |
423 | ||
424 | /* | |
425 | * Return current iteration position, advance internal iterator to next. | |
426 | * Return NULL if end of list. | |
427 | */ | |
428 | struct lttng_ust_field_iter * | |
429 | lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list) | |
430 | { | |
431 | struct tp_field_list_entry *entry; | |
432 | ||
433 | if (!list->iter) | |
434 | return NULL; | |
435 | entry = list->iter; | |
436 | if (entry->head.next == &list->head) | |
437 | list->iter = NULL; | |
438 | else | |
439 | list->iter = cds_list_entry(entry->head.next, | |
440 | struct tp_field_list_entry, head); | |
441 | return &entry->field; | |
442 | } |