Always evaluate BT_ASSERT(); add BT_ASSERT_DBG() for debug mode only
[babeltrace.git] / src / ctf-writer / trace.h
1 #ifndef BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
2 #define BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
3
4 /*
5 * Copyright 2014 EfficiOS Inc.
6 *
7 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
26 *
27 * The Common Trace Format (CTF) Specification is available at
28 * http://www.efficios.com/ctf
29 */
30
31 #include "common/macros.h"
32 #include "common/uuid.h"
33 #include <babeltrace2-ctf-writer/field-types.h>
34 #include <babeltrace2-ctf-writer/fields.h>
35 #include <babeltrace2-ctf-writer/trace.h>
36 #include <babeltrace2/types.h>
37 #include <glib.h>
38 #include <sys/types.h>
39
40 #include "assert-pre.h"
41 #include "attributes.h"
42 #include "clock-class.h"
43 #include "object.h"
44 #include "stream-class.h"
45 #include "validation.h"
46 #include "values.h"
47
48 struct bt_ctf_trace_common {
49 struct bt_ctf_object base;
50 GString *name;
51 int frozen;
52 bt_uuid_t uuid;
53 bt_ctf_bool uuid_set;
54 enum bt_ctf_byte_order native_byte_order;
55 struct bt_ctf_private_value *environment;
56 GPtrArray *clock_classes; /* Array of pointers to bt_ctf_clock_class */
57 GPtrArray *stream_classes; /* Array of ptrs to bt_ctf_stream_class_common */
58 GPtrArray *streams; /* Array of ptrs to bt_ctf_stream_common */
59 struct bt_ctf_field_type_common *packet_header_field_type;
60 int64_t next_stream_id;
61
62 /*
63 * This flag indicates if the trace is valid. A valid
64 * trace is _always_ frozen.
65 */
66 int valid;
67 };
68
69 BT_HIDDEN
70 bt_ctf_bool bt_ctf_trace_common_has_clock_class(struct bt_ctf_trace_common *trace,
71 struct bt_ctf_clock_class *clock_class);
72
73 BT_HIDDEN
74 int bt_ctf_trace_common_initialize(struct bt_ctf_trace_common *trace,
75 bt_ctf_object_release_func release_func);
76
77 BT_HIDDEN
78 void bt_ctf_trace_common_finalize(struct bt_ctf_trace_common *trace);
79
80 static inline
81 const char *bt_ctf_trace_common_get_name(struct bt_ctf_trace_common *trace)
82 {
83 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
84 return trace->name ? trace->name->str : NULL;
85 }
86
87 BT_HIDDEN
88 int bt_ctf_trace_common_set_name(struct bt_ctf_trace_common *trace, const char *name);
89
90 static inline
91 const uint8_t *bt_ctf_trace_common_get_uuid(struct bt_ctf_trace_common *trace)
92 {
93 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
94 return trace->uuid_set ? trace->uuid : NULL;
95 }
96
97 BT_HIDDEN
98 int bt_ctf_trace_common_set_uuid(struct bt_ctf_trace_common *trace, const uint8_t *uuid);
99
100 BT_HIDDEN
101 int bt_ctf_trace_common_set_environment_field(struct bt_ctf_trace_common *trace,
102 const char *name, struct bt_ctf_private_value *value);
103
104 BT_HIDDEN
105 int bt_ctf_trace_common_set_environment_field_string(struct bt_ctf_trace_common *trace,
106 const char *name, const char *value);
107
108 BT_HIDDEN
109 int bt_ctf_trace_common_set_environment_field_integer(struct bt_ctf_trace_common *trace,
110 const char *name, int64_t value);
111
112 static inline
113 int64_t bt_ctf_trace_common_get_environment_field_count(
114 struct bt_ctf_trace_common *trace)
115 {
116 int64_t ret;
117
118 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
119 ret = bt_ctf_attributes_get_count(trace->environment);
120 BT_ASSERT_DBG(ret >= 0);
121 return ret;
122 }
123
124 static inline
125 const char *
126 bt_ctf_trace_common_get_environment_field_name_by_index(
127 struct bt_ctf_trace_common *trace, uint64_t index)
128 {
129 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
130 return bt_ctf_attributes_get_field_name(trace->environment, index);
131 }
132
133 static inline
134 struct bt_ctf_private_value *
135 bt_ctf_trace_common_borrow_environment_field_value_by_index(
136 struct bt_ctf_trace_common *trace, uint64_t index)
137 {
138 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
139 return bt_ctf_attributes_borrow_field_value(trace->environment, index);
140 }
141
142 static inline
143 struct bt_ctf_private_value *
144 bt_ctf_trace_common_borrow_environment_field_value_by_name(
145 struct bt_ctf_trace_common *trace, const char *name)
146 {
147 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
148 BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
149 return bt_ctf_attributes_borrow_field_value_by_name(trace->environment,
150 name);
151 }
152
153 BT_HIDDEN
154 int bt_ctf_trace_common_add_clock_class(struct bt_ctf_trace_common *trace,
155 struct bt_ctf_clock_class *clock_class);
156
157 static inline
158 int64_t bt_ctf_trace_common_get_clock_class_count(struct bt_ctf_trace_common *trace)
159 {
160 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
161 return trace->clock_classes->len;
162 }
163
164 static inline
165 struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_index(
166 struct bt_ctf_trace_common *trace, uint64_t index)
167 {
168 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
169 BT_CTF_ASSERT_PRE(index < trace->clock_classes->len,
170 "Index is out of bounds: index=%" PRIu64 ", "
171 "count=%u",
172 index, trace->clock_classes->len);
173 return g_ptr_array_index(trace->clock_classes, index);
174 }
175
176 static inline
177 int64_t bt_ctf_trace_common_get_stream_count(struct bt_ctf_trace_common *trace)
178 {
179 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
180 return (int64_t) trace->streams->len;
181 }
182
183 static inline
184 struct bt_ctf_stream_common *bt_ctf_trace_common_borrow_stream_by_index(
185 struct bt_ctf_trace_common *trace,
186 uint64_t index)
187 {
188 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
189 BT_CTF_ASSERT_PRE(index < trace->streams->len,
190 "Index is out of bounds: index=%" PRIu64 ", "
191 "count=%u",
192 index, trace->streams->len);
193 return g_ptr_array_index(trace->streams, index);
194 }
195
196 static inline
197 int64_t bt_ctf_trace_common_get_stream_class_count(struct bt_ctf_trace_common *trace)
198 {
199 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
200 return (int64_t) trace->stream_classes->len;
201 }
202
203 static inline
204 struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_index(
205 struct bt_ctf_trace_common *trace, uint64_t index)
206 {
207 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
208 BT_CTF_ASSERT_PRE(index < trace->stream_classes->len,
209 "Index is out of bounds: index=%" PRIu64 ", "
210 "count=%u",
211 index, trace->stream_classes->len);
212 return g_ptr_array_index(trace->stream_classes, index);
213 }
214
215 static inline
216 struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_id(
217 struct bt_ctf_trace_common *trace, uint64_t id_param)
218 {
219 int i;
220 struct bt_ctf_stream_class_common *stream_class = NULL;
221 int64_t id = (int64_t) id_param;
222
223 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
224 BT_CTF_ASSERT_PRE(id >= 0,
225 "Invalid stream class ID: %" PRIu64, id_param);
226
227 for (i = 0; i < trace->stream_classes->len; i++) {
228 struct bt_ctf_stream_class_common *stream_class_candidate;
229
230 stream_class_candidate =
231 g_ptr_array_index(trace->stream_classes, i);
232
233 if (bt_ctf_stream_class_common_get_id(stream_class_candidate) ==
234 (int64_t) id) {
235 stream_class = stream_class_candidate;
236 goto end;
237 }
238 }
239
240 end:
241 return stream_class;
242 }
243
244 static inline
245 struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_name(
246 struct bt_ctf_trace_common *trace, const char *name)
247 {
248 size_t i;
249 struct bt_ctf_clock_class *clock_class = NULL;
250
251 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
252 BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
253
254 for (i = 0; i < trace->clock_classes->len; i++) {
255 struct bt_ctf_clock_class *cur_clk =
256 g_ptr_array_index(trace->clock_classes, i);
257 const char *cur_clk_name = bt_ctf_clock_class_get_name(cur_clk);
258
259 if (!cur_clk_name) {
260 goto end;
261 }
262
263 if (!strcmp(cur_clk_name, name)) {
264 clock_class = cur_clk;
265 goto end;
266 }
267 }
268
269 end:
270 return clock_class;
271 }
272
273 static inline
274 enum bt_ctf_byte_order bt_ctf_trace_common_get_native_byte_order(
275 struct bt_ctf_trace_common *trace)
276 {
277 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
278 return trace->native_byte_order;
279 }
280
281 BT_HIDDEN
282 int bt_ctf_trace_common_set_native_byte_order(struct bt_ctf_trace_common *trace,
283 enum bt_ctf_byte_order byte_order, bool allow_unspecified);
284
285 static inline
286 struct bt_ctf_field_type_common *bt_ctf_trace_common_borrow_packet_header_field_type(
287 struct bt_ctf_trace_common *trace)
288 {
289 BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
290 return trace->packet_header_field_type;
291 }
292
293 BT_HIDDEN
294 int bt_ctf_trace_common_set_packet_header_field_type(struct bt_ctf_trace_common *trace,
295 struct bt_ctf_field_type_common *packet_header_field_type);
296
297 static inline
298 void bt_ctf_trace_common_freeze(struct bt_ctf_trace_common *trace)
299 {
300 int i;
301
302 if (trace->frozen) {
303 return;
304 }
305
306 BT_LOGD("Freezing trace: addr=%p, name=\"%s\"",
307 trace, bt_ctf_trace_common_get_name(trace));
308 BT_LOGD_STR("Freezing packet header field type.");
309 bt_ctf_field_type_common_freeze(trace->packet_header_field_type);
310 BT_LOGD_STR("Freezing environment attributes.");
311 bt_ctf_attributes_freeze(trace->environment);
312
313 if (trace->clock_classes->len > 0) {
314 BT_LOGD_STR("Freezing clock classes.");
315 }
316
317 for (i = 0; i < trace->clock_classes->len; i++) {
318 struct bt_ctf_clock_class *clock_class =
319 g_ptr_array_index(trace->clock_classes, i);
320
321 bt_ctf_clock_class_freeze(clock_class);
322 }
323
324 trace->frozen = 1;
325 }
326
327 BT_HIDDEN
328 int bt_ctf_trace_common_add_stream_class(struct bt_ctf_trace_common *trace,
329 struct bt_ctf_stream_class_common *stream_class,
330 bt_ctf_validation_flag_copy_field_type_func copy_field_type_func,
331 struct bt_ctf_clock_class *init_expected_clock_class,
332 int (*map_clock_classes_func)(struct bt_ctf_stream_class_common *stream_class,
333 struct bt_ctf_field_type_common *packet_context_field_type,
334 struct bt_ctf_field_type_common *event_header_field_type),
335 bool check_ts_begin_end_mapped);
336
337 struct bt_ctf_trace {
338 struct bt_ctf_trace_common common;
339 };
340
341 /*
342 * bt_ctf_trace_get_metadata_string: get metadata string.
343 *
344 * Get the trace's TSDL metadata. The caller assumes the ownership of the
345 * returned string.
346 *
347 * @param trace Trace instance.
348 *
349 * Returns the metadata string on success, NULL on error.
350 */
351 BT_HIDDEN
352 char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace);
353
354 BT_HIDDEN
355 struct bt_ctf_trace *bt_ctf_trace_create(void);
356
357 BT_HIDDEN
358 int64_t bt_ctf_trace_get_clock_class_count(
359 struct bt_ctf_trace *trace);
360
361 BT_HIDDEN
362 struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_index(
363 struct bt_ctf_trace *trace, uint64_t index);
364
365 BT_HIDDEN
366 struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name(
367 struct bt_ctf_trace *trace, const char *name);
368
369 BT_HIDDEN
370 int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace,
371 struct bt_ctf_clock_class *clock_class);
372
373 BT_HIDDEN
374 int64_t bt_ctf_trace_get_environment_field_count(
375 struct bt_ctf_trace *trace);
376
377 BT_HIDDEN
378 const char *bt_ctf_trace_get_environment_field_name_by_index(
379 struct bt_ctf_trace *trace, uint64_t index);
380
381 BT_HIDDEN
382 struct bt_ctf_value *
383 bt_ctf_trace_get_environment_field_value_by_index(struct bt_ctf_trace *trace,
384 uint64_t index);
385
386 BT_HIDDEN
387 struct bt_ctf_value *
388 bt_ctf_trace_get_environment_field_value_by_name(
389 struct bt_ctf_trace *trace, const char *name);
390
391 #endif /* BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H */
This page took 0.037381 seconds and 4 git commands to generate.