Commit | Line | Data |
---|---|---|
8deee039 PP |
1 | /* |
2 | * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
3 | * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com> | |
4 | * | |
5 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
6 | * of this software and associated documentation files (the "Software"), to deal | |
7 | * in the Software without restriction, including without limitation the rights | |
8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
9 | * copies of the Software, and to permit persons to whom the Software is | |
10 | * furnished to do so, subject to the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be included in | |
13 | * all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
21 | * SOFTWARE. | |
22 | */ | |
23 | ||
24 | #define BT_LOG_TAG "CTF-WRITER-TRACE" | |
25 | #include <babeltrace/lib-logging-internal.h> | |
26 | ||
27 | #include <babeltrace/ctf-ir/trace-internal.h> | |
28 | #include <babeltrace/ctf-ir/clock-class.h> | |
29 | #include <babeltrace/ctf-writer/clock-internal.h> | |
30 | #include <babeltrace/ctf-writer/trace-internal.h> | |
31 | #include <babeltrace/ctf-writer/stream-class-internal.h> | |
32 | #include <babeltrace/ctf-writer/writer-internal.h> | |
33 | #include <babeltrace/ctf-writer/field-types-internal.h> | |
34 | ||
35 | #define DEFAULT_IDENTIFIER_SIZE 128 | |
36 | #define DEFAULT_METADATA_STRING_SIZE 4096 | |
37 | ||
38 | static | |
39 | void bt_ctf_trace_destroy(struct bt_object *obj) | |
40 | { | |
41 | struct bt_ctf_trace *trace = (void *) obj; | |
42 | ||
43 | BT_LOGD("Destroying CTF writer trace object: addr=%p, name=\"%s\"", | |
44 | trace, bt_ctf_trace_get_name(trace)); | |
45 | bt_trace_common_finalize(BT_TO_COMMON(trace)); | |
46 | g_free(trace); | |
47 | } | |
48 | ||
49 | BT_HIDDEN | |
50 | struct bt_ctf_trace *bt_ctf_trace_create(void) | |
51 | { | |
52 | struct bt_ctf_trace *trace = NULL; | |
53 | int ret; | |
54 | ||
55 | BT_LOGD_STR("Creating CTF writer trace object."); | |
56 | trace = g_new0(struct bt_ctf_trace, 1); | |
57 | if (!trace) { | |
58 | BT_LOGE_STR("Failed to allocate one CTF writer trace."); | |
59 | goto error; | |
60 | } | |
61 | ||
62 | ret = bt_trace_common_initialize(BT_TO_COMMON(trace), | |
63 | bt_ctf_trace_destroy); | |
64 | if (ret) { | |
65 | /* bt_trace_common_initialize() logs errors */ | |
66 | goto error; | |
67 | } | |
68 | ||
69 | BT_LOGD("Created CTF writer trace object: addr=%p", trace); | |
70 | return trace; | |
71 | ||
72 | error: | |
73 | BT_PUT(trace); | |
74 | return trace; | |
75 | } | |
76 | ||
77 | const unsigned char *bt_ctf_trace_get_uuid(struct bt_ctf_trace *trace) | |
78 | { | |
79 | return bt_trace_common_get_uuid(BT_TO_COMMON(trace)); | |
80 | } | |
81 | ||
82 | int bt_ctf_trace_set_uuid(struct bt_ctf_trace *trace, | |
83 | const unsigned char *uuid) | |
84 | { | |
85 | return bt_trace_common_set_uuid(BT_TO_COMMON(trace), uuid); | |
86 | } | |
87 | ||
88 | int bt_ctf_trace_set_environment_field(struct bt_ctf_trace *trace, | |
89 | const char *name, struct bt_value *value) | |
90 | { | |
91 | return bt_trace_common_set_environment_field(BT_TO_COMMON(trace), | |
92 | name, value); | |
93 | } | |
94 | ||
95 | int bt_ctf_trace_set_environment_field_string(struct bt_ctf_trace *trace, | |
96 | const char *name, const char *value) | |
97 | { | |
98 | return bt_trace_common_set_environment_field_string(BT_TO_COMMON(trace), | |
99 | name, value); | |
100 | } | |
101 | ||
102 | int bt_ctf_trace_set_environment_field_integer( | |
103 | struct bt_ctf_trace *trace, const char *name, int64_t value) | |
104 | { | |
105 | return bt_trace_common_set_environment_field_integer( | |
106 | BT_TO_COMMON(trace), name, value); | |
107 | } | |
108 | ||
109 | int64_t bt_ctf_trace_get_environment_field_count(struct bt_ctf_trace *trace) | |
110 | { | |
111 | return bt_trace_common_get_environment_field_count(BT_TO_COMMON(trace)); | |
112 | } | |
113 | ||
114 | const char * | |
115 | bt_ctf_trace_get_environment_field_name_by_index(struct bt_ctf_trace *trace, | |
116 | uint64_t index) | |
117 | { | |
118 | return bt_trace_common_get_environment_field_name_by_index( | |
119 | BT_TO_COMMON(trace), index); | |
120 | } | |
121 | ||
122 | struct bt_value *bt_ctf_trace_get_environment_field_value_by_index( | |
123 | struct bt_ctf_trace *trace, uint64_t index) | |
124 | { | |
5fe68922 PP |
125 | return bt_get(bt_trace_common_borrow_environment_field_value_by_index( |
126 | BT_TO_COMMON(trace), index)); | |
8deee039 PP |
127 | } |
128 | ||
129 | struct bt_value *bt_ctf_trace_get_environment_field_value_by_name( | |
130 | struct bt_ctf_trace *trace, const char *name) | |
131 | { | |
5fe68922 PP |
132 | return bt_get(bt_trace_common_borrow_environment_field_value_by_name( |
133 | BT_TO_COMMON(trace), name)); | |
8deee039 PP |
134 | } |
135 | ||
136 | int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace, | |
137 | struct bt_ctf_clock_class *clock_class) | |
138 | { | |
139 | return bt_trace_common_add_clock_class(BT_TO_COMMON(trace), | |
140 | (void *) clock_class); | |
141 | } | |
142 | ||
143 | int64_t bt_ctf_trace_get_clock_class_count(struct bt_ctf_trace *trace) | |
144 | { | |
145 | return bt_trace_common_get_clock_class_count(BT_TO_COMMON(trace)); | |
146 | } | |
147 | ||
148 | struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_index( | |
149 | struct bt_ctf_trace *trace, uint64_t index) | |
150 | { | |
5fe68922 PP |
151 | return bt_get(bt_trace_common_borrow_clock_class_by_index( |
152 | BT_TO_COMMON(trace), index)); | |
8deee039 PP |
153 | } |
154 | ||
155 | static | |
156 | int map_clock_classes_func(struct bt_stream_class_common *stream_class, | |
157 | struct bt_field_type_common *packet_context_type, | |
158 | struct bt_field_type_common *event_header_type) | |
159 | { | |
160 | int ret = bt_ctf_stream_class_map_clock_class( | |
161 | BT_FROM_COMMON(stream_class), | |
162 | BT_FROM_COMMON(packet_context_type), | |
163 | BT_FROM_COMMON(event_header_type)); | |
164 | ||
165 | if (ret) { | |
166 | BT_LOGW_STR("Cannot automatically map selected stream class's field types to stream class's clock's class."); | |
167 | } | |
168 | ||
169 | return ret; | |
170 | } | |
171 | ||
172 | int bt_ctf_trace_add_stream_class(struct bt_ctf_trace *trace, | |
173 | struct bt_ctf_stream_class *stream_class) | |
174 | { | |
175 | int ret = 0; | |
176 | struct bt_clock_class *expected_clock_class = NULL; | |
177 | ||
178 | if (!trace) { | |
179 | BT_LOGW_STR("Invalid parameter: trace is NULL."); | |
180 | ret = -1; | |
181 | goto end; | |
182 | } | |
183 | ||
184 | if (!stream_class) { | |
185 | BT_LOGW_STR("Invalid parameter: stream class is NULL."); | |
186 | ret = -1; | |
187 | goto end; | |
188 | } | |
189 | ||
190 | if (stream_class->clock) { | |
191 | struct bt_ctf_clock_class *stream_clock_class = | |
192 | stream_class->clock->clock_class; | |
193 | ||
194 | /* | |
195 | * Make sure this clock was also added to the | |
196 | * trace (potentially through its CTF writer | |
197 | * owner). | |
198 | */ | |
199 | size_t i; | |
200 | ||
201 | for (i = 0; i < trace->common.clock_classes->len; i++) { | |
202 | if (trace->common.clock_classes->pdata[i] == | |
203 | stream_clock_class) { | |
204 | /* Found! */ | |
205 | break; | |
206 | } | |
207 | } | |
208 | ||
209 | if (i == trace->common.clock_classes->len) { | |
210 | /* Not found */ | |
211 | BT_LOGW("Stream class's clock's class is not part of the trace: " | |
212 | "clock-class-addr=%p, clock-class-name=\"%s\"", | |
213 | stream_clock_class, | |
214 | bt_clock_class_get_name( | |
215 | BT_TO_COMMON(stream_clock_class))); | |
216 | ret = -1; | |
217 | goto end; | |
218 | } | |
219 | ||
220 | if (stream_class->common.clock_class && | |
221 | stream_class->common.clock_class != | |
222 | BT_TO_COMMON(stream_class->clock->clock_class)) { | |
223 | /* | |
224 | * Stream class already has an expected clock | |
225 | * class, but it does not match its clock's | |
226 | * class. | |
227 | */ | |
228 | BT_LOGW("Invalid parameter: stream class's clock's " | |
229 | "class does not match stream class's " | |
230 | "expected clock class: " | |
231 | "stream-class-addr=%p, " | |
232 | "stream-class-id=%" PRId64 ", " | |
233 | "stream-class-name=\"%s\", " | |
234 | "expected-clock-class-addr=%p, " | |
235 | "expected-clock-class-name=\"%s\"", | |
236 | stream_class, | |
237 | bt_ctf_stream_class_get_id(stream_class), | |
238 | bt_ctf_stream_class_get_name(stream_class), | |
239 | stream_class->common.clock_class, | |
240 | bt_clock_class_get_name(stream_class->common.clock_class)); | |
241 | } else if (!stream_class->common.clock_class) { | |
242 | /* | |
243 | * Set expected clock class to stream class's | |
244 | * clock's class. | |
245 | */ | |
246 | expected_clock_class = | |
247 | BT_TO_COMMON(stream_class->clock->clock_class); | |
248 | } | |
249 | } | |
250 | ||
251 | ||
252 | ret = bt_trace_common_add_stream_class(BT_TO_COMMON(trace), | |
253 | BT_TO_COMMON(stream_class), | |
254 | (bt_validation_flag_copy_field_type_func) bt_ctf_field_type_copy, | |
255 | expected_clock_class, map_clock_classes_func, | |
256 | false); | |
257 | ||
258 | end: | |
259 | return ret; | |
260 | } | |
261 | ||
262 | int64_t bt_ctf_trace_get_stream_count(struct bt_ctf_trace *trace) | |
263 | { | |
264 | return bt_trace_common_get_stream_count(BT_TO_COMMON(trace)); | |
265 | } | |
266 | ||
267 | struct bt_ctf_stream *bt_ctf_trace_get_stream_by_index( | |
268 | struct bt_ctf_trace *trace, uint64_t index) | |
269 | { | |
5fe68922 | 270 | return bt_get(bt_trace_common_borrow_stream_by_index( |
8deee039 PP |
271 | BT_TO_COMMON(trace), index)); |
272 | } | |
273 | ||
274 | int64_t bt_ctf_trace_get_stream_class_count(struct bt_ctf_trace *trace) | |
275 | { | |
276 | return bt_trace_common_get_stream_class_count(BT_TO_COMMON(trace)); | |
277 | } | |
278 | ||
279 | struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class_by_index( | |
280 | struct bt_ctf_trace *trace, uint64_t index) | |
281 | { | |
5fe68922 | 282 | return bt_get(bt_trace_common_borrow_stream_class_by_index( |
8deee039 PP |
283 | BT_TO_COMMON(trace), index)); |
284 | } | |
285 | ||
286 | struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class_by_id( | |
287 | struct bt_ctf_trace *trace, uint64_t id) | |
288 | { | |
5fe68922 PP |
289 | return bt_get(bt_trace_common_borrow_stream_class_by_id( |
290 | BT_TO_COMMON(trace), id)); | |
8deee039 PP |
291 | } |
292 | ||
293 | struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name( | |
294 | struct bt_ctf_trace *trace, const char *name) | |
295 | { | |
5fe68922 PP |
296 | return bt_get( |
297 | bt_trace_common_borrow_clock_class_by_name(BT_TO_COMMON(trace), | |
8deee039 PP |
298 | name)); |
299 | } | |
300 | ||
301 | static | |
302 | int append_trace_metadata(struct bt_ctf_trace *trace, | |
303 | struct metadata_context *context) | |
304 | { | |
305 | unsigned char *uuid = trace->common.uuid; | |
306 | int ret = 0; | |
307 | ||
308 | if (trace->common.native_byte_order == BT_BYTE_ORDER_NATIVE || | |
309 | trace->common.native_byte_order == BT_BYTE_ORDER_UNSPECIFIED) { | |
310 | BT_LOGW("Invalid parameter: trace's byte order cannot be BT_CTF_BYTE_ORDER_NATIVE or BT_CTF_BYTE_ORDER_UNSPECIFIED at this point; " | |
311 | "set it with bt_ctf_trace_set_native_byte_order(): " | |
312 | "addr=%p, name=\"%s\"", | |
313 | trace, bt_ctf_trace_get_name(trace)); | |
314 | ret = -1; | |
315 | goto end; | |
316 | } | |
317 | ||
318 | g_string_append(context->string, "trace {\n"); | |
319 | g_string_append(context->string, "\tmajor = 1;\n"); | |
320 | g_string_append(context->string, "\tminor = 8;\n"); | |
321 | BT_ASSERT(trace->common.native_byte_order == BT_BYTE_ORDER_LITTLE_ENDIAN || | |
322 | trace->common.native_byte_order == BT_BYTE_ORDER_BIG_ENDIAN || | |
323 | trace->common.native_byte_order == BT_BYTE_ORDER_NETWORK); | |
324 | ||
325 | if (trace->common.uuid_set) { | |
326 | g_string_append_printf(context->string, | |
327 | "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n", | |
328 | uuid[0], uuid[1], uuid[2], uuid[3], | |
329 | uuid[4], uuid[5], uuid[6], uuid[7], | |
330 | uuid[8], uuid[9], uuid[10], uuid[11], | |
331 | uuid[12], uuid[13], uuid[14], uuid[15]); | |
332 | } | |
333 | ||
334 | g_string_append_printf(context->string, "\tbyte_order = %s;\n", | |
335 | get_byte_order_string(trace->common.native_byte_order)); | |
336 | ||
337 | if (trace->common.packet_header_field_type) { | |
338 | g_string_append(context->string, "\tpacket.header := "); | |
339 | context->current_indentation_level++; | |
340 | g_string_assign(context->field_name, ""); | |
341 | BT_LOGD_STR("Serializing trace's packet header field type's metadata."); | |
342 | ret = bt_ctf_field_type_serialize_recursive( | |
343 | (void *) trace->common.packet_header_field_type, | |
344 | context); | |
345 | if (ret) { | |
346 | goto end; | |
347 | } | |
348 | context->current_indentation_level--; | |
349 | } | |
350 | ||
351 | g_string_append(context->string, ";\n};\n\n"); | |
352 | end: | |
353 | return ret; | |
354 | } | |
355 | ||
356 | static | |
357 | void append_env_metadata(struct bt_ctf_trace *trace, | |
358 | struct metadata_context *context) | |
359 | { | |
360 | int64_t i; | |
361 | int64_t env_size; | |
362 | ||
363 | env_size = bt_attributes_get_count(trace->common.environment); | |
364 | if (env_size <= 0) { | |
365 | return; | |
366 | } | |
367 | ||
368 | g_string_append(context->string, "env {\n"); | |
369 | ||
370 | for (i = 0; i < env_size; i++) { | |
371 | struct bt_value *env_field_value_obj = NULL; | |
372 | const char *entry_name; | |
373 | ||
374 | entry_name = bt_attributes_get_field_name( | |
375 | trace->common.environment, i); | |
5fe68922 | 376 | env_field_value_obj = bt_attributes_borrow_field_value( |
8deee039 PP |
377 | trace->common.environment, i); |
378 | ||
379 | BT_ASSERT(entry_name); | |
380 | BT_ASSERT(env_field_value_obj); | |
381 | ||
382 | switch (bt_value_get_type(env_field_value_obj)) { | |
383 | case BT_VALUE_TYPE_INTEGER: | |
384 | { | |
385 | int ret; | |
386 | int64_t int_value; | |
387 | ||
388 | ret = bt_value_integer_get(env_field_value_obj, | |
389 | &int_value); | |
390 | BT_ASSERT(ret == 0); | |
391 | g_string_append_printf(context->string, | |
392 | "\t%s = %" PRId64 ";\n", entry_name, | |
393 | int_value); | |
394 | break; | |
395 | } | |
396 | case BT_VALUE_TYPE_STRING: | |
397 | { | |
398 | int ret; | |
399 | const char *str_value; | |
400 | char *escaped_str = NULL; | |
401 | ||
402 | ret = bt_value_string_get(env_field_value_obj, | |
403 | &str_value); | |
404 | BT_ASSERT(ret == 0); | |
405 | escaped_str = g_strescape(str_value, NULL); | |
406 | if (!escaped_str) { | |
407 | BT_LOGE("Cannot escape string: string=\"%s\"", | |
408 | str_value); | |
5fe68922 | 409 | continue; |
8deee039 PP |
410 | } |
411 | ||
412 | g_string_append_printf(context->string, | |
413 | "\t%s = \"%s\";\n", entry_name, escaped_str); | |
414 | free(escaped_str); | |
415 | break; | |
416 | } | |
417 | default: | |
5fe68922 | 418 | continue; |
8deee039 | 419 | } |
8deee039 PP |
420 | } |
421 | ||
422 | g_string_append(context->string, "};\n\n"); | |
423 | } | |
424 | ||
425 | char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace) | |
426 | { | |
427 | char *metadata = NULL; | |
428 | struct metadata_context *context = NULL; | |
429 | int err = 0; | |
430 | size_t i; | |
431 | ||
432 | if (!trace) { | |
433 | BT_LOGW_STR("Invalid parameter: trace is NULL."); | |
434 | goto end; | |
435 | } | |
436 | ||
437 | context = g_new0(struct metadata_context, 1); | |
438 | if (!context) { | |
439 | BT_LOGE_STR("Failed to allocate one metadata context."); | |
440 | goto end; | |
441 | } | |
442 | ||
443 | context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE); | |
444 | context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE); | |
445 | g_string_append(context->string, "/* CTF 1.8 */\n\n"); | |
446 | if (append_trace_metadata(trace, context)) { | |
447 | /* append_trace_metadata() logs errors */ | |
448 | goto error; | |
449 | } | |
450 | append_env_metadata(trace, context); | |
451 | g_ptr_array_foreach(trace->common.clock_classes, | |
452 | (GFunc) bt_ctf_clock_class_serialize, context); | |
453 | ||
454 | for (i = 0; i < trace->common.stream_classes->len; i++) { | |
455 | /* bt_stream_class_serialize() logs details */ | |
456 | err = bt_ctf_stream_class_serialize( | |
457 | trace->common.stream_classes->pdata[i], context); | |
458 | if (err) { | |
459 | /* bt_stream_class_serialize() logs errors */ | |
460 | goto error; | |
461 | } | |
462 | } | |
463 | ||
464 | metadata = context->string->str; | |
465 | ||
466 | error: | |
467 | g_string_free(context->string, err ? TRUE : FALSE); | |
468 | g_string_free(context->field_name, TRUE); | |
469 | g_free(context); | |
470 | ||
471 | end: | |
472 | return metadata; | |
473 | } | |
474 | ||
475 | enum bt_ctf_byte_order bt_ctf_trace_get_native_byte_order( | |
476 | struct bt_ctf_trace *trace) | |
477 | { | |
478 | return (int) bt_trace_common_get_native_byte_order(BT_TO_COMMON(trace)); | |
479 | } | |
480 | ||
481 | int bt_ctf_trace_set_native_byte_order(struct bt_ctf_trace *trace, | |
482 | enum bt_ctf_byte_order byte_order) | |
483 | { | |
484 | return bt_trace_common_set_native_byte_order(BT_TO_COMMON(trace), | |
485 | (int) byte_order, false); | |
486 | } | |
487 | ||
488 | struct bt_ctf_field_type *bt_ctf_trace_get_packet_header_field_type( | |
489 | struct bt_ctf_trace *trace) | |
490 | { | |
5fe68922 | 491 | return bt_get(bt_trace_common_borrow_packet_header_field_type( |
8deee039 PP |
492 | BT_TO_COMMON(trace))); |
493 | } | |
494 | ||
495 | int bt_ctf_trace_set_packet_header_field_type(struct bt_ctf_trace *trace, | |
496 | struct bt_ctf_field_type *packet_header_type) | |
497 | { | |
498 | return bt_trace_common_set_packet_header_field_type(BT_TO_COMMON(trace), | |
499 | (void *) packet_header_type); | |
500 | } | |
501 | ||
502 | const char *bt_ctf_trace_get_name(struct bt_ctf_trace *trace) | |
503 | { | |
504 | return bt_trace_common_get_name(BT_TO_COMMON(trace)); | |
505 | } |