6 * Copyright 2011-2012 EfficiOS Inc. and Linux Foundation
8 * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * Julien Desfossez <julien.desfossez@efficios.com>
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this software and associated documentation files (the "Software"), to deal
13 * in the Software without restriction, including without limitation the rights
14 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 * copies of the Software, and to permit persons to whom the Software is
16 * furnished to do so, subject to the following conditions:
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
22 #include <babeltrace/babeltrace.h>
23 #include <babeltrace/format.h>
24 #include <babeltrace/ctf/events.h>
25 #include <babeltrace/ctf-ir/metadata.h>
26 #include <babeltrace/prio_heap.h>
27 #include <babeltrace/iterator-internal.h>
28 #include <babeltrace/ctf/events-internal.h>
29 #include <babeltrace/ctf/metadata.h>
32 #include "events-private.h"
35 * thread local storage to store the last error that occured
36 * while reading a field, this variable must be accessed by
37 * bt_ctf_field_error only
39 __thread
int bt_ctf_last_field_error
= 0;
41 struct bt_ctf_iter
*bt_ctf_iter_create(struct bt_context
*ctx
,
42 struct bt_iter_pos
*begin_pos
,
43 struct bt_iter_pos
*end_pos
)
45 struct bt_ctf_iter
*iter
;
48 iter
= g_new0(struct bt_ctf_iter
, 1);
49 ret
= bt_iter_init(&iter
->parent
, ctx
, begin_pos
, end_pos
);
54 iter
->callbacks
= g_array_new(0, 1, sizeof(struct bt_stream_callbacks
));
55 iter
->recalculate_dep_graph
= 0;
56 iter
->main_callbacks
.callback
= NULL
;
57 iter
->dep_gc
= g_ptr_array_new();
61 void bt_ctf_iter_destroy(struct bt_ctf_iter
*iter
)
63 struct bt_stream_callbacks
*bt_stream_cb
;
64 struct bt_callback_chain
*bt_chain
;
67 /* free all events callbacks */
68 if (iter
->main_callbacks
.callback
)
69 g_array_free(iter
->main_callbacks
.callback
, TRUE
);
71 /* free per-event callbacks */
72 for (i
= 0; i
< iter
->callbacks
->len
; i
++) {
73 bt_stream_cb
= &g_array_index(iter
->callbacks
,
74 struct bt_stream_callbacks
, i
);
75 if (!bt_stream_cb
|| !bt_stream_cb
->per_id_callbacks
)
77 for (j
= 0; j
< bt_stream_cb
->per_id_callbacks
->len
; j
++) {
78 bt_chain
= &g_array_index(bt_stream_cb
->per_id_callbacks
,
79 struct bt_callback_chain
, j
);
80 if (bt_chain
->callback
) {
81 g_array_free(bt_chain
->callback
, TRUE
);
84 g_array_free(bt_stream_cb
->per_id_callbacks
, TRUE
);
87 bt_iter_fini(&iter
->parent
);
91 struct bt_iter
*bt_ctf_get_iter(struct bt_ctf_iter
*iter
)
96 struct bt_ctf_event
*bt_ctf_iter_read_event(struct bt_ctf_iter
*iter
)
98 struct ctf_file_stream
*file_stream
;
99 struct bt_ctf_event
*ret
= &iter
->current_ctf_event
;
101 file_stream
= heap_maximum(iter
->parent
.stream_heap
);
103 /* end of file for all streams */
106 ret
->stream
= &file_stream
->parent
;
107 ret
->event
= g_ptr_array_index(ret
->stream
->events_by_id
,
108 ret
->stream
->event_id
);
110 if (ret
->stream
->stream_id
> iter
->callbacks
->len
)
113 process_callbacks(iter
, ret
->stream
);
121 struct definition
*bt_ctf_get_top_level_scope(struct bt_ctf_event
*event
,
122 enum bt_ctf_scope scope
)
124 struct definition
*tmp
= NULL
;
127 case BT_TRACE_PACKET_HEADER
:
130 if (event
->stream
->trace_packet_header
)
131 tmp
= &event
->stream
->trace_packet_header
->p
;
133 case BT_STREAM_PACKET_CONTEXT
:
136 if (event
->stream
->stream_packet_context
)
137 tmp
= &event
->stream
->stream_packet_context
->p
;
139 case BT_STREAM_EVENT_HEADER
:
142 if (event
->stream
->stream_event_header
)
143 tmp
= &event
->stream
->stream_event_header
->p
;
145 case BT_STREAM_EVENT_CONTEXT
:
148 if (event
->stream
->stream_event_context
)
149 tmp
= &event
->stream
->stream_event_context
->p
;
151 case BT_EVENT_CONTEXT
:
154 if (event
->event
->event_context
)
155 tmp
= &event
->event
->event_context
->p
;
157 case BT_EVENT_FIELDS
:
160 if (event
->event
->event_fields
)
161 tmp
= &event
->event
->event_fields
->p
;
170 struct definition
*bt_ctf_get_field(struct bt_ctf_event
*event
,
171 struct definition
*scope
,
174 struct definition
*def
;
175 char *field_underscore
;
178 def
= lookup_definition(scope
, field
);
180 * optionally a field can have an underscore prefix, try
181 * to lookup the field with this prefix if it failed
184 field_underscore
= g_new(char, strlen(field
) + 2);
185 field_underscore
[0] = '_';
186 strcpy(&field_underscore
[1], field
);
187 def
= lookup_definition(scope
, field_underscore
);
188 g_free(field_underscore
);
190 if (bt_ctf_field_type(def
) == CTF_TYPE_VARIANT
) {
191 struct definition_variant
*variant_definition
;
192 variant_definition
= container_of(def
,
193 struct definition_variant
, p
);
194 return variant_definition
->current_field
;
201 struct definition
*bt_ctf_get_index(struct bt_ctf_event
*event
,
202 struct definition
*field
,
205 struct definition
*ret
= NULL
;
207 if (bt_ctf_field_type(field
) == CTF_TYPE_ARRAY
) {
208 struct definition_array
*array_definition
;
209 array_definition
= container_of(field
,
210 struct definition_array
, p
);
211 ret
= array_index(array_definition
, index
);
212 } else if (bt_ctf_field_type(field
) == CTF_TYPE_SEQUENCE
) {
213 struct definition_sequence
*sequence_definition
;
214 sequence_definition
= container_of(field
,
215 struct definition_sequence
, p
);
216 ret
= sequence_index(sequence_definition
, index
);
221 const char *bt_ctf_event_name(struct bt_ctf_event
*event
)
223 struct ctf_event
*event_class
;
224 struct ctf_stream_class
*stream_class
;
228 stream_class
= event
->stream
->stream_class
;
229 event_class
= g_ptr_array_index(stream_class
->events_by_id
,
230 event
->stream
->event_id
);
231 return g_quark_to_string(event_class
->name
);
234 const char *bt_ctf_field_name(const struct definition
*def
)
237 return rem_(g_quark_to_string(def
->name
));
241 enum ctf_type_id
bt_ctf_field_type(const struct definition
*def
)
244 return def
->declaration
->id
;
245 return CTF_TYPE_UNKNOWN
;
248 int bt_ctf_get_field_list(struct bt_ctf_event
*event
,
249 struct definition
*scope
,
250 struct definition
const * const **list
,
253 switch (bt_ctf_field_type(scope
)) {
254 case CTF_TYPE_INTEGER
:
256 case CTF_TYPE_STRING
:
259 case CTF_TYPE_STRUCT
:
261 struct definition_struct
*def_struct
;
263 def_struct
= container_of(scope
, struct definition_struct
, p
);
266 if (def_struct
->fields
->pdata
) {
267 *list
= (struct definition
const* const*) def_struct
->fields
->pdata
;
268 *count
= def_struct
->fields
->len
;
274 case CTF_TYPE_UNTAGGED_VARIANT
:
276 case CTF_TYPE_VARIANT
:
278 struct definition_variant
*def_variant
;
280 def_variant
= container_of(scope
, struct definition_variant
, p
);
283 if (def_variant
->fields
->pdata
) {
284 *list
= (struct definition
const* const*) def_variant
->fields
->pdata
;
285 *count
= def_variant
->fields
->len
;
293 struct definition_array
*def_array
;
295 def_array
= container_of(scope
, struct definition_array
, p
);
298 if (def_array
->elems
->pdata
) {
299 *list
= (struct definition
const* const*) def_array
->elems
->pdata
;
300 *count
= def_array
->elems
->len
;
306 case CTF_TYPE_SEQUENCE
:
308 struct definition_sequence
*def_sequence
;
310 def_sequence
= container_of(scope
, struct definition_sequence
, p
);
313 if (def_sequence
->elems
->pdata
) {
314 *list
= (struct definition
const* const*) def_sequence
->elems
->pdata
;
315 *count
= def_sequence
->elems
->len
;
334 uint64_t bt_ctf_get_timestamp_raw(struct bt_ctf_event
*event
)
336 if (event
&& event
->stream
->has_timestamp
)
337 return ctf_get_timestamp_raw(event
->stream
,
338 event
->stream
->timestamp
);
343 uint64_t bt_ctf_get_timestamp(struct bt_ctf_event
*event
)
345 if (event
&& event
->stream
->has_timestamp
)
346 return ctf_get_timestamp(event
->stream
,
347 event
->stream
->timestamp
);
352 static void bt_ctf_field_set_error(int error
)
354 bt_ctf_last_field_error
= error
;
357 int bt_ctf_field_get_error(void)
360 ret
= bt_ctf_last_field_error
;
361 bt_ctf_last_field_error
= 0;
366 int bt_ctf_get_int_signedness(const struct definition
*field
)
370 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_INTEGER
) {
371 ret
= get_int_signedness(field
);
374 bt_ctf_field_set_error(-EINVAL
);
380 int bt_ctf_get_int_base(const struct definition
*field
)
384 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_INTEGER
) {
385 ret
= get_int_base(field
);
388 bt_ctf_field_set_error(-EINVAL
);
394 int bt_ctf_get_int_byte_order(const struct definition
*field
)
398 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_INTEGER
) {
399 ret
= get_int_byte_order(field
);
402 bt_ctf_field_set_error(-EINVAL
);
408 enum ctf_string_encoding
bt_ctf_get_encoding(const struct definition
*field
)
410 enum ctf_string_encoding ret
= 0;
415 if (bt_ctf_field_type(field
) == CTF_TYPE_INTEGER
)
416 ret
= get_int_encoding(field
);
417 else if (bt_ctf_field_type(field
) == CTF_TYPE_STRING
)
418 ret
= get_string_encoding(field
);
426 bt_ctf_field_set_error(-EINVAL
);
430 int bt_ctf_get_array_len(const struct definition
*field
)
434 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_ARRAY
) {
435 ret
= get_array_len(field
);
438 bt_ctf_field_set_error(-EINVAL
);
444 uint64_t bt_ctf_get_uint64(const struct definition
*field
)
446 unsigned int ret
= 0;
448 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_INTEGER
)
449 ret
= get_unsigned_int(field
);
451 bt_ctf_field_set_error(-EINVAL
);
456 int64_t bt_ctf_get_int64(const struct definition
*field
)
460 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_INTEGER
)
461 ret
= get_signed_int(field
);
463 bt_ctf_field_set_error(-EINVAL
);
469 char *bt_ctf_get_char_array(const struct definition
*field
)
473 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_ARRAY
)
474 ret
= get_char_array(field
)->str
;
476 bt_ctf_field_set_error(-EINVAL
);
481 char *bt_ctf_get_string(const struct definition
*field
)
485 if (field
&& bt_ctf_field_type(field
) == CTF_TYPE_STRING
)
486 ret
= get_string(field
);
488 bt_ctf_field_set_error(-EINVAL
);