4 * Holds LTTng probes registry.
6 * Copyright 2010-2012 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; only
11 * version 2.1 of the License.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include <urcu/list.h>
27 #include <urcu/hlist.h>
28 #include <lttng/ust-events.h>
29 #include <lttng/tracepoint.h>
30 #include "tracepoint-internal.h"
35 #include "lttng-tracer-core.h"
40 * probe list is protected by ust_lock()/ust_unlock().
42 static CDS_LIST_HEAD(_probe_list
);
45 * List of probes registered by not yet processed.
47 static CDS_LIST_HEAD(lazy_probe_init
);
50 * lazy_nesting counter ensures we don't trigger lazy probe registration
51 * fixup while we are performing the fixup. It is protected by the ust
54 static int lazy_nesting
;
57 * Called under ust lock.
60 int check_event_provider(struct lttng_probe_desc
*desc
)
63 size_t provider_name_len
;
65 provider_name_len
= strnlen(desc
->provider
,
66 LTTNG_UST_SYM_NAME_LEN
- 1);
67 for (i
= 0; i
< desc
->nr_events
; i
++) {
68 if (strncmp(desc
->event_desc
[i
]->name
,
71 return 0; /* provider mismatch */
77 * Called under ust lock.
80 void lttng_lazy_probe_register(struct lttng_probe_desc
*desc
)
82 struct lttng_probe_desc
*iter
;
83 struct cds_list_head
*probe_list
;
86 * Each provider enforce that every event name begins with the
87 * provider name. Check this in an assertion for extra
88 * carefulness. This ensures we cannot have duplicate event
89 * names across providers.
91 assert(check_event_provider(desc
));
94 * The provider ensures there are no duplicate event names.
95 * Duplicated TRACEPOINT_EVENT event names would generate a
96 * compile-time error due to duplicated symbol names.
100 * We sort the providers by struct lttng_probe_desc pointer
103 probe_list
= &_probe_list
;
104 cds_list_for_each_entry_reverse(iter
, probe_list
, head
) {
105 BUG_ON(iter
== desc
); /* Should never be in the list twice */
107 /* We belong to the location right after iter. */
108 cds_list_add(&desc
->head
, &iter
->head
);
112 /* We should be added at the head of the list */
113 cds_list_add(&desc
->head
, probe_list
);
115 DBG("just registered probe %s containing %u events",
116 desc
->provider
, desc
->nr_events
);
120 * Called under ust lock.
123 void fixup_lazy_probes(void)
125 struct lttng_probe_desc
*iter
, *tmp
;
129 cds_list_for_each_entry_safe(iter
, tmp
,
130 &lazy_probe_init
, lazy_init_head
) {
131 lttng_lazy_probe_register(iter
);
133 cds_list_del(&iter
->lazy_init_head
);
135 ret
= lttng_fix_pending_events();
141 * Called under ust lock.
143 struct cds_list_head
*lttng_get_probe_list_head(void)
145 if (!lazy_nesting
&& !cds_list_empty(&lazy_probe_init
))
151 const struct lttng_probe_desc
*find_provider(const char *provider
)
153 struct lttng_probe_desc
*iter
;
154 struct cds_list_head
*probe_list
;
156 probe_list
= lttng_get_probe_list_head();
157 cds_list_for_each_entry(iter
, probe_list
, head
) {
158 if (!strcmp(iter
->provider
, provider
))
165 int check_provider_version(struct lttng_probe_desc
*desc
)
168 * Check tracepoint provider version compatibility.
170 if (desc
->major
<= LTTNG_UST_PROVIDER_MAJOR
) {
171 DBG("Provider \"%s\" accepted, version %u.%u is compatible "
172 "with LTTng UST provider version %u.%u.",
173 desc
->provider
, desc
->major
, desc
->minor
,
174 LTTNG_UST_PROVIDER_MAJOR
,
175 LTTNG_UST_PROVIDER_MINOR
);
176 if (desc
->major
< LTTNG_UST_PROVIDER_MAJOR
) {
177 DBG("However, some LTTng UST features might not be "
178 "available for this provider unless it is "
179 "recompiled against a more recent LTTng UST.");
181 return 1; /* accept */
183 ERR("Provider \"%s\" rejected, version %u.%u is incompatible "
184 "with LTTng UST provider version %u.%u. Please upgrade "
186 desc
->provider
, desc
->major
, desc
->minor
,
187 LTTNG_UST_PROVIDER_MAJOR
,
188 LTTNG_UST_PROVIDER_MINOR
);
189 return 0; /* reject */
194 int lttng_probe_register(struct lttng_probe_desc
*desc
)
198 lttng_ust_fixup_tls();
201 * If version mismatch, don't register, but don't trigger assert
202 * on caller. The version check just prints an error.
204 if (!check_provider_version(desc
))
210 * Check if the provider has already been registered.
212 if (find_provider(desc
->provider
)) {
216 cds_list_add(&desc
->lazy_init_head
, &lazy_probe_init
);
218 DBG("adding probe %s containing %u events to lazy registration list",
219 desc
->provider
, desc
->nr_events
);
221 * If there is at least one active session, we need to register
222 * the probe immediately, since we cannot delay event
223 * registration because they are needed ASAP.
225 if (lttng_session_active())
232 /* Backward compatibility with UST 2.0 */
233 int ltt_probe_register(struct lttng_probe_desc
*desc
)
235 return lttng_probe_register(desc
);
238 void lttng_probe_unregister(struct lttng_probe_desc
*desc
)
240 lttng_ust_fixup_tls();
242 if (!check_provider_version(desc
))
247 cds_list_del(&desc
->head
);
249 cds_list_del(&desc
->lazy_init_head
);
250 DBG("just unregistered probe %s", desc
->provider
);
254 /* Backward compatibility with UST 2.0 */
255 void ltt_probe_unregister(struct lttng_probe_desc
*desc
)
257 lttng_probe_unregister(desc
);
260 void lttng_probes_prune_event_list(struct lttng_ust_tracepoint_list
*list
)
262 struct tp_list_entry
*list_entry
, *tmp
;
264 cds_list_for_each_entry_safe(list_entry
, tmp
, &list
->head
, head
) {
265 cds_list_del(&list_entry
->head
);
271 * called with UST lock held.
273 int lttng_probes_get_event_list(struct lttng_ust_tracepoint_list
*list
)
275 struct lttng_probe_desc
*probe_desc
;
277 struct cds_list_head
*probe_list
;
279 probe_list
= lttng_get_probe_list_head();
280 CDS_INIT_LIST_HEAD(&list
->head
);
281 cds_list_for_each_entry(probe_desc
, probe_list
, head
) {
282 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
283 struct tp_list_entry
*list_entry
;
285 list_entry
= zmalloc(sizeof(*list_entry
));
288 cds_list_add(&list_entry
->head
, &list
->head
);
289 strncpy(list_entry
->tp
.name
,
290 probe_desc
->event_desc
[i
]->name
,
291 LTTNG_UST_SYM_NAME_LEN
);
292 list_entry
->tp
.name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
293 if (!probe_desc
->event_desc
[i
]->loglevel
) {
294 list_entry
->tp
.loglevel
= TRACE_DEFAULT
;
296 list_entry
->tp
.loglevel
= *(*probe_desc
->event_desc
[i
]->loglevel
);
300 if (cds_list_empty(&list
->head
))
304 cds_list_first_entry(&list
->head
, struct tp_list_entry
, head
);
308 lttng_probes_prune_event_list(list
);
313 * Return current iteration position, advance internal iterator to next.
314 * Return NULL if end of list.
316 struct lttng_ust_tracepoint_iter
*
317 lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list
*list
)
319 struct tp_list_entry
*entry
;
324 if (entry
->head
.next
== &list
->head
)
327 list
->iter
= cds_list_entry(entry
->head
.next
,
328 struct tp_list_entry
, head
);
332 void lttng_probes_prune_field_list(struct lttng_ust_field_list
*list
)
334 struct tp_field_list_entry
*list_entry
, *tmp
;
336 cds_list_for_each_entry_safe(list_entry
, tmp
, &list
->head
, head
) {
337 cds_list_del(&list_entry
->head
);
343 * called with UST lock held.
345 int lttng_probes_get_field_list(struct lttng_ust_field_list
*list
)
347 struct lttng_probe_desc
*probe_desc
;
349 struct cds_list_head
*probe_list
;
351 probe_list
= lttng_get_probe_list_head();
352 CDS_INIT_LIST_HEAD(&list
->head
);
353 cds_list_for_each_entry(probe_desc
, probe_list
, head
) {
354 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
355 const struct lttng_event_desc
*event_desc
=
356 probe_desc
->event_desc
[i
];
359 if (event_desc
->nr_fields
== 0) {
360 /* Events without fields. */
361 struct tp_field_list_entry
*list_entry
;
363 list_entry
= zmalloc(sizeof(*list_entry
));
366 cds_list_add(&list_entry
->head
, &list
->head
);
367 strncpy(list_entry
->field
.event_name
,
369 LTTNG_UST_SYM_NAME_LEN
);
370 list_entry
->field
.event_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
371 list_entry
->field
.field_name
[0] = '\0';
372 list_entry
->field
.type
= LTTNG_UST_FIELD_OTHER
;
373 if (!event_desc
->loglevel
) {
374 list_entry
->field
.loglevel
= TRACE_DEFAULT
;
376 list_entry
->field
.loglevel
= *(*event_desc
->loglevel
);
378 list_entry
->field
.nowrite
= 1;
381 for (j
= 0; j
< event_desc
->nr_fields
; j
++) {
382 const struct lttng_event_field
*event_field
=
383 &event_desc
->fields
[j
];
384 struct tp_field_list_entry
*list_entry
;
386 list_entry
= zmalloc(sizeof(*list_entry
));
389 cds_list_add(&list_entry
->head
, &list
->head
);
390 strncpy(list_entry
->field
.event_name
,
392 LTTNG_UST_SYM_NAME_LEN
);
393 list_entry
->field
.event_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
394 strncpy(list_entry
->field
.field_name
,
396 LTTNG_UST_SYM_NAME_LEN
);
397 list_entry
->field
.field_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
398 switch (event_field
->type
.atype
) {
400 list_entry
->field
.type
= LTTNG_UST_FIELD_INTEGER
;
403 list_entry
->field
.type
= LTTNG_UST_FIELD_STRING
;
406 if (event_field
->type
.u
.array
.elem_type
.atype
!= atype_integer
407 || event_field
->type
.u
.array
.elem_type
.u
.basic
.integer
.encoding
== lttng_encode_none
)
408 list_entry
->field
.type
= LTTNG_UST_FIELD_OTHER
;
410 list_entry
->field
.type
= LTTNG_UST_FIELD_STRING
;
413 if (event_field
->type
.u
.sequence
.elem_type
.atype
!= atype_integer
414 || event_field
->type
.u
.sequence
.elem_type
.u
.basic
.integer
.encoding
== lttng_encode_none
)
415 list_entry
->field
.type
= LTTNG_UST_FIELD_OTHER
;
417 list_entry
->field
.type
= LTTNG_UST_FIELD_STRING
;
420 list_entry
->field
.type
= LTTNG_UST_FIELD_FLOAT
;
423 list_entry
->field
.type
= LTTNG_UST_FIELD_ENUM
;
426 list_entry
->field
.type
= LTTNG_UST_FIELD_OTHER
;
428 if (!event_desc
->loglevel
) {
429 list_entry
->field
.loglevel
= TRACE_DEFAULT
;
431 list_entry
->field
.loglevel
= *(*event_desc
->loglevel
);
433 list_entry
->field
.nowrite
= event_field
->nowrite
;
437 if (cds_list_empty(&list
->head
))
441 cds_list_first_entry(&list
->head
,
442 struct tp_field_list_entry
, head
);
446 lttng_probes_prune_field_list(list
);
451 * Return current iteration position, advance internal iterator to next.
452 * Return NULL if end of list.
454 struct lttng_ust_field_iter
*
455 lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list
*list
)
457 struct tp_field_list_entry
*entry
;
462 if (entry
->head
.next
== &list
->head
)
465 list
->iter
= cds_list_entry(entry
->head
.next
,
466 struct tp_field_list_entry
, head
);
467 return &entry
->field
;