projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove Babeltrace 1 files and reorganize the tree
[babeltrace.git] / lib / ctf-ir / trace.c
1 /*
2 * trace.c
3 *
4 * Babeltrace CTF IR - Trace
5 *
6 * Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
7 *
8 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * SOFTWARE.
27 */
28
29 #include <babeltrace/ctf-ir/trace-internal.h>
30 #include <babeltrace/ctf-ir/clock-class-internal.h>
31 #include <babeltrace/ctf-ir/stream-internal.h>
32 #include <babeltrace/ctf-ir/stream-class-internal.h>
33 #include <babeltrace/ctf-ir/event-internal.h>
34 #include <babeltrace/ctf-ir/event-class.h>
35 #include <babeltrace/ctf-ir/event-class-internal.h>
36 #include <babeltrace/ctf-writer/functor-internal.h>
37 #include <babeltrace/ctf-writer/clock-internal.h>
38 #include <babeltrace/ctf-ir/field-types-internal.h>
39 #include <babeltrace/ctf-ir/attributes-internal.h>
40 #include <babeltrace/ctf-ir/validation-internal.h>
41 #include <babeltrace/ctf-ir/visitor-internal.h>
42 #include <babeltrace/ctf-ir/utils.h>
43 #include <babeltrace/graph/notification-schema.h>
44 #include <babeltrace/compiler.h>
45 #include <babeltrace/values.h>
46 #include <babeltrace/ref.h>
47 #include <babeltrace/endian.h>
48 #include <inttypes.h>
49
50 #define DEFAULT_IDENTIFIER_SIZE 128
51 #define DEFAULT_METADATA_STRING_SIZE 4096
52
53 struct listener_wrapper {
54 bt_ctf_listener_cb listener;
55 void *data;
56 };
57
58 static
59 void bt_ctf_trace_destroy(struct bt_object *obj);
60 static
61 int init_trace_packet_header(struct bt_ctf_trace *trace);
62 static
63 void bt_ctf_trace_freeze(struct bt_ctf_trace *trace);
64
65 static
66 const unsigned int field_type_aliases_alignments[] = {
67 [FIELD_TYPE_ALIAS_UINT5_T] = 1,
68 [FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
69 [FIELD_TYPE_ALIAS_UINT27_T] = 1,
70 [FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
71 };
72
73 static
74 const unsigned int field_type_aliases_sizes[] = {
75 [FIELD_TYPE_ALIAS_UINT5_T] = 5,
76 [FIELD_TYPE_ALIAS_UINT8_T] = 8,
77 [FIELD_TYPE_ALIAS_UINT16_T] = 16,
78 [FIELD_TYPE_ALIAS_UINT27_T] = 27,
79 [FIELD_TYPE_ALIAS_UINT32_T] = 32,
80 [FIELD_TYPE_ALIAS_UINT64_T] = 64,
81 };
82
83 struct bt_ctf_trace *bt_ctf_trace_create(void)
84 {
85 struct bt_ctf_trace *trace = NULL;
86
87 trace = g_new0(struct bt_ctf_trace, 1);
88 if (!trace) {
89 goto error;
90 }
91
92 bt_ctf_trace_set_byte_order(trace, BT_CTF_BYTE_ORDER_NATIVE);
93 bt_object_init(trace, bt_ctf_trace_destroy);
94 trace->clocks = g_ptr_array_new_with_free_func(
95 (GDestroyNotify) bt_put);
96 trace->streams = g_ptr_array_new_with_free_func(
97 (GDestroyNotify) bt_object_release);
98 trace->stream_classes = g_ptr_array_new_with_free_func(
99 (GDestroyNotify) bt_object_release);
100 if (!trace->clocks || !trace->stream_classes || !trace->streams) {
101 goto error;
102 }
103
104 /* Generate a trace UUID */
105 uuid_generate(trace->uuid);
106 if (init_trace_packet_header(trace)) {
107 goto error;
108 }
109
110 /* Create the environment array object */
111 trace->environment = bt_ctf_attributes_create();
112 if (!trace->environment) {
113 goto error;
114 }
115
116 trace->listeners = g_ptr_array_new_with_free_func(
117 (GDestroyNotify) g_free);
118 if (!trace->listeners) {
119 goto error;
120 }
121
122 return trace;
123
124 error:
125 BT_PUT(trace);
126 return trace;
127 }
128
129 const char *bt_ctf_trace_get_name(struct bt_ctf_trace *trace)
130 {
131 const char *name = NULL;
132
133 if (!trace || !trace->name) {
134 goto end;
135 }
136
137 name = trace->name->str;
138 end:
139 return name;
140 }
141
142 int bt_ctf_trace_set_name(struct bt_ctf_trace *trace, const char *name)
143 {
144 int ret = 0;
145
146 if (!trace || !name || trace->frozen) {
147 ret = -1;
148 goto end;
149 }
150
151 trace->name = trace->name ? g_string_assign(trace->name, name) :
152 g_string_new(name);
153 if (!trace->name) {
154 ret = -1;
155 goto end;
156 }
157 end:
158 return ret;
159 }
160
161 void bt_ctf_trace_destroy(struct bt_object *obj)
162 {
163 struct bt_ctf_trace *trace;
164
165 trace = container_of(obj, struct bt_ctf_trace, base);
166 if (trace->environment) {
167 bt_ctf_attributes_destroy(trace->environment);
168 }
169
170 if (trace->name) {
171 g_string_free(trace->name, TRUE);
172 }
173
174 if (trace->clocks) {
175 g_ptr_array_free(trace->clocks, TRUE);
176 }
177
178 if (trace->streams) {
179 g_ptr_array_free(trace->streams, TRUE);
180 }
181
182 if (trace->stream_classes) {
183 g_ptr_array_free(trace->stream_classes, TRUE);
184 }
185
186 if (trace->listeners) {
187 g_ptr_array_free(trace->listeners, TRUE);
188 }
189
190 bt_put(trace->packet_header_type);
191 g_free(trace);
192 }
193
194 int bt_ctf_trace_set_environment_field(struct bt_ctf_trace *trace,
195 const char *name, struct bt_value *value)
196 {
197 int ret = 0;
198
199 if (!trace || !name || !value ||
200 bt_ctf_validate_identifier(name) ||
201 !(bt_value_is_integer(value) || bt_value_is_string(value))) {
202 ret = -1;
203 goto end;
204 }
205
206 if (strchr(name, ' ')) {
207 ret = -1;
208 goto end;
209 }
210
211 if (trace->frozen) {
212 /*
213 * New environment fields may be added to a frozen trace,
214 * but existing fields may not be changed.
215 *
216 * The object passed is frozen like all other attributes.
217 */
218 struct bt_value *attribute =
219 bt_ctf_attributes_get_field_value_by_name(
220 trace->environment, name);
221
222 if (attribute) {
223 BT_PUT(attribute);
224 ret = -1;
225 goto end;
226 }
227
228 bt_value_freeze(value);
229 }
230
231 ret = bt_ctf_attributes_set_field_value(trace->environment, name,
232 value);
233
234 end:
235 return ret;
236 }
237
238 int bt_ctf_trace_set_environment_field_string(struct bt_ctf_trace *trace,
239 const char *name, const char *value)
240 {
241 int ret = 0;
242 struct bt_value *env_value_string_obj = NULL;
243
244 if (!trace || !name || !value) {
245 ret = -1;
246 goto end;
247 }
248
249 if (trace->frozen) {
250 /*
251 * New environment fields may be added to a frozen trace,
252 * but existing fields may not be changed.
253 */
254 struct bt_value *attribute =
255 bt_ctf_attributes_get_field_value_by_name(
256 trace->environment, name);
257
258 if (attribute) {
259 BT_PUT(attribute);
260 ret = -1;
261 goto end;
262 }
263 }
264
265 env_value_string_obj = bt_value_string_create_init(value);
266
267 if (!env_value_string_obj) {
268 ret = -1;
269 goto end;
270 }
271
272 if (trace->frozen) {
273 bt_value_freeze(env_value_string_obj);
274 }
275 ret = bt_ctf_trace_set_environment_field(trace, name,
276 env_value_string_obj);
277
278 end:
279 BT_PUT(env_value_string_obj);
280 return ret;
281 }
282
283 int bt_ctf_trace_set_environment_field_integer(struct bt_ctf_trace *trace,
284 const char *name, int64_t value)
285 {
286 int ret = 0;
287 struct bt_value *env_value_integer_obj = NULL;
288
289 if (!trace || !name) {
290 ret = -1;
291 goto end;
292 }
293
294 if (trace->frozen) {
295 /*
296 * New environment fields may be added to a frozen trace,
297 * but existing fields may not be changed.
298 */
299 struct bt_value *attribute =
300 bt_ctf_attributes_get_field_value_by_name(
301 trace->environment, name);
302
303 if (attribute) {
304 BT_PUT(attribute);
305 ret = -1;
306 goto end;
307 }
308 }
309
310 env_value_integer_obj = bt_value_integer_create_init(value);
311 if (!env_value_integer_obj) {
312 ret = -1;
313 goto end;
314 }
315
316 ret = bt_ctf_trace_set_environment_field(trace, name,
317 env_value_integer_obj);
318 if (trace->frozen) {
319 bt_value_freeze(env_value_integer_obj);
320 }
321 end:
322 BT_PUT(env_value_integer_obj);
323 return ret;
324 }
325
326 int bt_ctf_trace_get_environment_field_count(struct bt_ctf_trace *trace)
327 {
328 int ret = 0;
329
330 if (!trace) {
331 ret = -1;
332 goto end;
333 }
334
335 ret = bt_ctf_attributes_get_count(trace->environment);
336
337 end:
338 return ret;
339 }
340
341 const char *
342 bt_ctf_trace_get_environment_field_name(struct bt_ctf_trace *trace,
343 int index)
344 {
345 const char *ret = NULL;
346
347 if (!trace) {
348 goto end;
349 }
350
351 ret = bt_ctf_attributes_get_field_name(trace->environment, index);
352
353 end:
354 return ret;
355 }
356
357 struct bt_value *bt_ctf_trace_get_environment_field_value(
358 struct bt_ctf_trace *trace, int index)
359 {
360 struct bt_value *ret = NULL;
361
362 if (!trace) {
363 goto end;
364 }
365
366 ret = bt_ctf_attributes_get_field_value(trace->environment, index);
367
368 end:
369 return ret;
370 }
371
372 struct bt_value *bt_ctf_trace_get_environment_field_value_by_name(
373 struct bt_ctf_trace *trace, const char *name)
374 {
375 struct bt_value *ret = NULL;
376
377 if (!trace || !name) {
378 goto end;
379 }
380
381 ret = bt_ctf_attributes_get_field_value_by_name(trace->environment,
382 name);
383
384 end:
385 return ret;
386 }
387
388 int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace,
389 struct bt_ctf_clock_class *clock_class)
390 {
391 int ret = 0;
392 struct search_query query = { .value = clock_class, .found = 0 };
393
394 if (!trace || !bt_ctf_clock_class_is_valid(clock_class)) {
395 ret = -1;
396 goto end;
397 }
398
399 /* Check for duplicate clock classes */
400 g_ptr_array_foreach(trace->clocks, value_exists, &query);
401 if (query.found) {
402 ret = -1;
403 goto end;
404 }
405
406 bt_get(clock_class);
407 g_ptr_array_add(trace->clocks, clock_class);
408
409 if (trace->frozen) {
410 bt_ctf_clock_class_freeze(clock_class);
411 }
412 end:
413 return ret;
414 }
415
416 int bt_ctf_trace_get_clock_class_count(struct bt_ctf_trace *trace)
417 {
418 int ret = -1;
419
420 if (!trace) {
421 goto end;
422 }
423
424 ret = trace->clocks->len;
425 end:
426 return ret;
427 }
428
429 struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class(
430 struct bt_ctf_trace *trace, int index)
431 {
432 struct bt_ctf_clock_class *clock_class = NULL;
433
434 if (!trace || index < 0 || index >= trace->clocks->len) {
435 goto end;
436 }
437
438 clock_class = g_ptr_array_index(trace->clocks, index);
439 bt_get(clock_class);
440 end:
441 return clock_class;
442 }
443
444 int bt_ctf_trace_add_stream_class(struct bt_ctf_trace *trace,
445 struct bt_ctf_stream_class *stream_class)
446 {
447 int ret, i;
448 int64_t stream_id;
449 struct bt_ctf_validation_output trace_sc_validation_output = { 0 };
450 struct bt_ctf_validation_output *ec_validation_outputs = NULL;
451 const enum bt_ctf_validation_flag trace_sc_validation_flags =
452 BT_CTF_VALIDATION_FLAG_TRACE |
453 BT_CTF_VALIDATION_FLAG_STREAM;
454 const enum bt_ctf_validation_flag ec_validation_flags =
455 BT_CTF_VALIDATION_FLAG_EVENT;
456 struct bt_ctf_field_type *packet_header_type = NULL;
457 struct bt_ctf_field_type *packet_context_type = NULL;
458 struct bt_ctf_field_type *event_header_type = NULL;
459 struct bt_ctf_field_type *stream_event_ctx_type = NULL;
460 int event_class_count;
461 struct bt_ctf_trace *current_parent_trace = NULL;
462
463 if (!trace || !stream_class) {
464 ret = -1;
465 goto end;
466 }
467
468 current_parent_trace = bt_ctf_stream_class_get_trace(stream_class);
469 if (current_parent_trace) {
470 /* Stream class is already associated to a trace, abort. */
471 ret = -1;
472 goto end;
473 }
474
475 event_class_count =
476 bt_ctf_stream_class_get_event_class_count(stream_class);
477 assert(event_class_count >= 0);
478
479 /* Check for duplicate stream classes */
480 for (i = 0; i < trace->stream_classes->len; i++) {
481 if (trace->stream_classes->pdata[i] == stream_class) {
482 /* Stream class already registered to the trace */
483 ret = -1;
484 goto end;
485 }
486 }
487
488 if (stream_class->clock) {
489 struct bt_ctf_clock_class *stream_clock_class =
490 stream_class->clock->clock_class;
491
492 if (trace->is_created_by_writer) {
493 /*
494 * Make sure this clock was also added to the
495 * trace (potentially through its CTF writer
496 * owner).
497 */
498 size_t i;
499
500 for (i = 0; i < trace->clocks->len; i++) {
501 if (trace->clocks->pdata[i] ==
502 stream_clock_class) {
503 /* Found! */
504 break;
505 }
506 }
507
508 if (i == trace->clocks->len) {
509 /* Not found */
510 ret = -1;
511 goto end;
512 }
513 } else {
514 /*
515 * This trace was NOT created by a CTF writer,
516 * thus do not allow the stream class to add to
517 * have a clock at all. Those are two
518 * independent APIs (non-writer and writer
519 * APIs), and isolating them simplifies things.
520 */
521 ret = -1;
522 goto end;
523 }
524 }
525
526 /*
527 * We're about to freeze both the trace and the stream class.
528 * Also, each event class contained in this stream class are
529 * already frozen.
530 *
531 * This trace, this stream class, and all its event classes
532 * should be valid at this point.
533 *
534 * Validate trace and stream class first, then each event
535 * class of this stream class can be validated individually.
536 */
537 packet_header_type =
538 bt_ctf_trace_get_packet_header_type(trace);
539 packet_context_type =
540 bt_ctf_stream_class_get_packet_context_type(stream_class);
541 event_header_type =
542 bt_ctf_stream_class_get_event_header_type(stream_class);
543 stream_event_ctx_type =
544 bt_ctf_stream_class_get_event_context_type(stream_class);
545 ret = bt_ctf_validate_class_types(trace->environment,
546 packet_header_type, packet_context_type, event_header_type,
547 stream_event_ctx_type, NULL, NULL, trace->valid,
548 stream_class->valid, 1, &trace_sc_validation_output,
549 trace_sc_validation_flags);
550 BT_PUT(packet_header_type);
551 BT_PUT(packet_context_type);
552 BT_PUT(event_header_type);
553 BT_PUT(stream_event_ctx_type);
554
555 if (ret) {
556 /*
557 * This means something went wrong during the validation
558 * process, not that the objects are invalid.
559 */
560 goto end;
561 }
562
563 if ((trace_sc_validation_output.valid_flags &
564 trace_sc_validation_flags) !=
565 trace_sc_validation_flags) {
566 /* Invalid trace/stream class */
567 ret = -1;
568 goto end;
569 }
570
571 if (event_class_count > 0) {
572 ec_validation_outputs = g_new0(struct bt_ctf_validation_output,
573 event_class_count);
574 if (!ec_validation_outputs) {
575 ret = -1;
576 goto end;
577 }
578 }
579
580 /* Validate each event class individually */
581 for (i = 0; i < event_class_count; i++) {
582 struct bt_ctf_event_class *event_class =
583 bt_ctf_stream_class_get_event_class(stream_class, i);
584 struct bt_ctf_field_type *event_context_type = NULL;
585 struct bt_ctf_field_type *event_payload_type = NULL;
586
587 event_context_type =
588 bt_ctf_event_class_get_context_type(event_class);
589 event_payload_type =
590 bt_ctf_event_class_get_payload_type(event_class);
591
592 /*
593 * It is important to use the field types returned by
594 * the previous trace and stream class validation here
595 * because copies could have been made.
596 */
597 ret = bt_ctf_validate_class_types(trace->environment,
598 trace_sc_validation_output.packet_header_type,
599 trace_sc_validation_output.packet_context_type,
600 trace_sc_validation_output.event_header_type,
601 trace_sc_validation_output.stream_event_ctx_type,
602 event_context_type, event_payload_type,
603 1, 1, event_class->valid, &ec_validation_outputs[i],
604 ec_validation_flags);
605 BT_PUT(event_context_type);
606 BT_PUT(event_payload_type);
607 BT_PUT(event_class);
608
609 if (ret) {
610 goto end;
611 }
612
613 if ((ec_validation_outputs[i].valid_flags &
614 ec_validation_flags) != ec_validation_flags) {
615 /* Invalid event class */
616 ret = -1;
617 goto end;
618 }
619 }
620
621 stream_id = bt_ctf_stream_class_get_id(stream_class);
622 if (stream_id < 0) {
623 stream_id = trace->next_stream_id++;
624
625 /* Try to assign a new stream id */
626 for (i = 0; i < trace->stream_classes->len; i++) {
627 if (stream_id == bt_ctf_stream_class_get_id(
628 trace->stream_classes->pdata[i])) {
629 /* Duplicate stream id found */
630 ret = -1;
631 goto end;
632 }
633 }
634
635 if (bt_ctf_stream_class_set_id_no_check(stream_class,
636 stream_id)) {
637 /* TODO Should retry with a different stream id */
638 ret = -1;
639 goto end;
640 }
641 }
642
643 bt_object_set_parent(stream_class, trace);
644 g_ptr_array_add(trace->stream_classes, stream_class);
645
646 /*
647 * At this point we know that the function will be successful.
648 * Therefore we can replace the trace and stream class field
649 * types with what's in their validation output structure and
650 * mark them as valid. We can also replace the field types of
651 * all the event classes of the stream class and mark them as
652 * valid.
653 */
654 bt_ctf_validation_replace_types(trace, stream_class, NULL,
655 &trace_sc_validation_output, trace_sc_validation_flags);
656 trace->valid = 1;
657 stream_class->valid = 1;
658
659 /*
660 * Put what was not moved in bt_ctf_validation_replace_types().
661 */
662 bt_ctf_validation_output_put_types(&trace_sc_validation_output);
663
664 for (i = 0; i < event_class_count; i++) {
665 struct bt_ctf_event_class *event_class =
666 bt_ctf_stream_class_get_event_class(stream_class, i);
667
668 bt_ctf_validation_replace_types(NULL, NULL, event_class,
669 &ec_validation_outputs[i], ec_validation_flags);
670 event_class->valid = 1;
671 BT_PUT(event_class);
672
673 /*
674 * Put what was not moved in
675 * bt_ctf_validation_replace_types().
676 */
677 bt_ctf_validation_output_put_types(&ec_validation_outputs[i]);
678 }
679
680 /*
681 * Freeze the trace and the stream class.
682 */
683 bt_ctf_stream_class_freeze(stream_class);
684 bt_ctf_trace_freeze(trace);
685
686 /* Notifiy listeners of the trace's schema modification. */
687 bt_ctf_stream_class_visit(stream_class,
688 bt_ctf_trace_object_modification, trace);
689 end:
690 if (ret) {
691 bt_object_set_parent(stream_class, NULL);
692
693 if (ec_validation_outputs) {
694 for (i = 0; i < event_class_count; i++) {
695 bt_ctf_validation_output_put_types(
696 &ec_validation_outputs[i]);
697 }
698 }
699 }
700
701 g_free(ec_validation_outputs);
702 bt_ctf_validation_output_put_types(&trace_sc_validation_output);
703 bt_put(current_parent_trace);
704 assert(!packet_header_type);
705 assert(!packet_context_type);
706 assert(!event_header_type);
707 assert(!stream_event_ctx_type);
708
709 return ret;
710 }
711
712 int bt_ctf_trace_get_stream_class_count(struct bt_ctf_trace *trace)
713 {
714 int ret;
715
716 if (!trace) {
717 ret = -1;
718 goto end;
719 }
720
721 ret = trace->stream_classes->len;
722 end:
723 return ret;
724 }
725
726 struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class(
727 struct bt_ctf_trace *trace, int index)
728 {
729 struct bt_ctf_stream_class *stream_class = NULL;
730
731 if (!trace || index < 0 || index >= trace->stream_classes->len) {
732 goto end;
733 }
734
735 stream_class = g_ptr_array_index(trace->stream_classes, index);
736 bt_get(stream_class);
737 end:
738 return stream_class;
739 }
740
741 struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class_by_id(
742 struct bt_ctf_trace *trace, uint32_t id)
743 {
744 int i;
745 struct bt_ctf_stream_class *stream_class = NULL;
746
747 if (!trace) {
748 goto end;
749 }
750
751 for (i = 0; i < trace->stream_classes->len; i++) {
752 struct bt_ctf_stream_class *stream_class_candidate;
753
754 stream_class_candidate =
755 g_ptr_array_index(trace->stream_classes, i);
756
757 if (bt_ctf_stream_class_get_id(stream_class_candidate) ==
758 (int64_t) id) {
759 stream_class = stream_class_candidate;
760 bt_get(stream_class);
761 goto end;
762 }
763 }
764
765 end:
766 return stream_class;
767 }
768
769 struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name(
770 struct bt_ctf_trace *trace, const char *name)
771 {
772 size_t i;
773 struct bt_ctf_clock_class *clock_class = NULL;
774
775 if (!trace || !name) {
776 goto end;
777 }
778
779 for (i = 0; i < trace->clocks->len; i++) {
780 struct bt_ctf_clock_class *cur_clk =
781 g_ptr_array_index(trace->clocks, i);
782 const char *cur_clk_name = bt_ctf_clock_class_get_name(cur_clk);
783
784 if (!cur_clk_name) {
785 goto end;
786 }
787
788 if (!strcmp(cur_clk_name, name)) {
789 clock_class = cur_clk;
790 bt_get(clock_class);
791 goto end;
792 }
793 }
794
795 end:
796 return clock_class;
797 }
798
799 BT_HIDDEN
800 const char *get_byte_order_string(enum bt_ctf_byte_order byte_order)
801 {
802 const char *string;
803
804 switch (byte_order) {
805 case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
806 string = "le";
807 break;
808 case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
809 string = "be";
810 break;
811 case BT_CTF_BYTE_ORDER_NATIVE:
812 string = "native";
813 break;
814 default:
815 assert(false);
816 }
817
818 return string;
819 }
820
821 static
822 int append_trace_metadata(struct bt_ctf_trace *trace,
823 struct metadata_context *context)
824 {
825 unsigned char *uuid = trace->uuid;
826 int ret;
827
828 g_string_append(context->string, "trace {\n");
829
830 g_string_append(context->string, "\tmajor = 1;\n");
831 g_string_append(context->string, "\tminor = 8;\n");
832 assert(trace->native_byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ||
833 trace->native_byte_order == BT_CTF_BYTE_ORDER_BIG_ENDIAN ||
834 trace->native_byte_order == BT_CTF_BYTE_ORDER_NETWORK);
835 g_string_append_printf(context->string,
836 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
837 uuid[0], uuid[1], uuid[2], uuid[3],
838 uuid[4], uuid[5], uuid[6], uuid[7],
839 uuid[8], uuid[9], uuid[10], uuid[11],
840 uuid[12], uuid[13], uuid[14], uuid[15]);
841 g_string_append_printf(context->string, "\tbyte_order = %s;\n",
842 get_byte_order_string(trace->native_byte_order));
843
844 g_string_append(context->string, "\tpacket.header := ");
845 context->current_indentation_level++;
846 g_string_assign(context->field_name, "");
847 ret = bt_ctf_field_type_serialize(trace->packet_header_type,
848 context);
849 if (ret) {
850 goto end;
851 }
852 context->current_indentation_level--;
853
854 g_string_append(context->string, ";\n};\n\n");
855 end:
856 return ret;
857 }
858
859 static
860 void append_env_metadata(struct bt_ctf_trace *trace,
861 struct metadata_context *context)
862 {
863 int i;
864 int env_size;
865
866 env_size = bt_ctf_attributes_get_count(trace->environment);
867
868 if (env_size <= 0) {
869 return;
870 }
871
872 g_string_append(context->string, "env {\n");
873
874 for (i = 0; i < env_size; i++) {
875 struct bt_value *env_field_value_obj = NULL;
876 const char *entry_name;
877
878 entry_name = bt_ctf_attributes_get_field_name(
879 trace->environment, i);
880 env_field_value_obj = bt_ctf_attributes_get_field_value(
881 trace->environment, i);
882
883 if (!entry_name || !env_field_value_obj) {
884 goto loop_next;
885 }
886
887 switch (bt_value_get_type(env_field_value_obj)) {
888 case BT_VALUE_TYPE_INTEGER:
889 {
890 int ret;
891 int64_t int_value;
892
893 ret = bt_value_integer_get(env_field_value_obj,
894 &int_value);
895
896 if (ret) {
897 goto loop_next;
898 }
899
900 g_string_append_printf(context->string,
901 "\t%s = %" PRId64 ";\n", entry_name,
902 int_value);
903 break;
904 }
905 case BT_VALUE_TYPE_STRING:
906 {
907 int ret;
908 const char *str_value;
909 char *escaped_str = NULL;
910
911 ret = bt_value_string_get(env_field_value_obj,
912 &str_value);
913
914 if (ret) {
915 goto loop_next;
916 }
917
918 escaped_str = g_strescape(str_value, NULL);
919
920 if (!escaped_str) {
921 goto loop_next;
922 }
923
924 g_string_append_printf(context->string,
925 "\t%s = \"%s\";\n", entry_name, escaped_str);
926 free(escaped_str);
927 break;
928 }
929
930 default:
931 goto loop_next;
932 }
933
934 loop_next:
935 BT_PUT(env_field_value_obj);
936 }
937
938 g_string_append(context->string, "};\n\n");
939 }
940
941 char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace)
942 {
943 char *metadata = NULL;
944 struct metadata_context *context = NULL;
945 int err = 0;
946 size_t i;
947
948 if (!trace) {
949 goto end;
950 }
951
952 context = g_new0(struct metadata_context, 1);
953 if (!context) {
954 goto end;
955 }
956
957 context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
958 context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
959 g_string_append(context->string, "/* CTF 1.8 */\n\n");
960 if (append_trace_metadata(trace, context)) {
961 goto error;
962 }
963 append_env_metadata(trace, context);
964 g_ptr_array_foreach(trace->clocks,
965 (GFunc)bt_ctf_clock_class_serialize, context);
966
967 for (i = 0; i < trace->stream_classes->len; i++) {
968 err = bt_ctf_stream_class_serialize(
969 trace->stream_classes->pdata[i], context);
970 if (err) {
971 goto error;
972 }
973 }
974
975 metadata = context->string->str;
976 error:
977 g_string_free(context->string, err ? TRUE : FALSE);
978 g_string_free(context->field_name, TRUE);
979 g_free(context);
980 end:
981 return metadata;
982 }
983
984 enum bt_ctf_byte_order bt_ctf_trace_get_byte_order(struct bt_ctf_trace *trace)
985 {
986 enum bt_ctf_byte_order ret = BT_CTF_BYTE_ORDER_UNKNOWN;
987
988 if (!trace) {
989 goto end;
990 }
991
992 ret = trace->native_byte_order;
993
994 end:
995 return ret;
996 }
997
998 int bt_ctf_trace_set_byte_order(struct bt_ctf_trace *trace,
999 enum bt_ctf_byte_order byte_order)
1000 {
1001 int ret = 0;
1002
1003 if (!trace || trace->frozen) {
1004 ret = -1;
1005 goto end;
1006 }
1007
1008 if (byte_order != BT_CTF_BYTE_ORDER_LITTLE_ENDIAN &&
1009 byte_order != BT_CTF_BYTE_ORDER_BIG_ENDIAN &&
1010 byte_order != BT_CTF_BYTE_ORDER_NETWORK) {
1011 ret = -1;
1012 goto end;
1013 }
1014
1015 trace->native_byte_order = byte_order;
1016
1017 end:
1018 return ret;
1019 }
1020
1021 struct bt_ctf_field_type *bt_ctf_trace_get_packet_header_type(
1022 struct bt_ctf_trace *trace)
1023 {
1024 struct bt_ctf_field_type *field_type = NULL;
1025
1026 if (!trace) {
1027 goto end;
1028 }
1029
1030 bt_get(trace->packet_header_type);
1031 field_type = trace->packet_header_type;
1032 end:
1033 return field_type;
1034 }
1035
1036 int bt_ctf_trace_set_packet_header_type(struct bt_ctf_trace *trace,
1037 struct bt_ctf_field_type *packet_header_type)
1038 {
1039 int ret = 0;
1040
1041 if (!trace || trace->frozen) {
1042 ret = -1;
1043 goto end;
1044 }
1045
1046 /* packet_header_type must be a structure. */
1047 if (packet_header_type &&
1048 bt_ctf_field_type_get_type_id(packet_header_type) !=
1049 BT_CTF_TYPE_ID_STRUCT) {
1050 ret = -1;
1051 goto end;
1052 }
1053
1054 bt_put(trace->packet_header_type);
1055 trace->packet_header_type = bt_get(packet_header_type);
1056 end:
1057 return ret;
1058 }
1059
1060 static
1061 int get_stream_class_count(void *element)
1062 {
1063 return bt_ctf_trace_get_stream_class_count(
1064 (struct bt_ctf_trace *) element);
1065 }
1066
1067 static
1068 void *get_stream_class(void *element, int i)
1069 {
1070 return bt_ctf_trace_get_stream_class(
1071 (struct bt_ctf_trace *) element, i);
1072 }
1073
1074 static
1075 int visit_stream_class(void *object, bt_ctf_visitor visitor,void *data)
1076 {
1077 return bt_ctf_stream_class_visit(object, visitor, data);
1078 }
1079
1080 int bt_ctf_trace_visit(struct bt_ctf_trace *trace,
1081 bt_ctf_visitor visitor, void *data)
1082 {
1083 int ret;
1084 struct bt_ctf_object obj =
1085 { .object = trace, .type = BT_CTF_OBJECT_TYPE_TRACE };
1086
1087 if (!trace || !visitor) {
1088 ret = -1;
1089 goto end;
1090 }
1091
1092 ret = visitor_helper(&obj, get_stream_class_count,
1093 get_stream_class, visit_stream_class, visitor, data);
1094 end:
1095 return ret;
1096 }
1097
1098 static
1099 int invoke_listener(struct bt_ctf_object *object, void *data)
1100 {
1101 struct listener_wrapper *listener_wrapper = data;
1102
1103 listener_wrapper->listener(object, listener_wrapper->data);
1104 return 0;
1105 }
1106
1107 int bt_ctf_trace_add_listener(struct bt_ctf_trace *trace,
1108 bt_ctf_listener_cb listener, void *listener_data)
1109 {
1110 int ret = 0;
1111 struct listener_wrapper *listener_wrapper =
1112 g_new0(struct listener_wrapper, 1);
1113
1114 if (!trace || !listener || !listener_wrapper) {
1115 ret = -1;
1116 goto error;
1117 }
1118
1119 listener_wrapper->listener = listener;
1120 listener_wrapper->data = listener_data;
1121
1122 /* Visit the current schema. */
1123 ret = bt_ctf_trace_visit(trace, invoke_listener, listener_wrapper);
1124 if (ret) {
1125 goto error;
1126 }
1127
1128 /*
1129 * Add listener to the array of callbacks which will be invoked on
1130 * schema changes.
1131 */
1132 g_ptr_array_add(trace->listeners, listener_wrapper);
1133 return ret;
1134 error:
1135 g_free(listener_wrapper);
1136 return ret;
1137 }
1138
1139 BT_HIDDEN
1140 int bt_ctf_trace_object_modification(struct bt_ctf_object *object,
1141 void *trace_ptr)
1142 {
1143 size_t i;
1144 struct bt_ctf_trace *trace = trace_ptr;
1145
1146 assert(trace);
1147 assert(object);
1148
1149 if (trace->listeners->len == 0) {
1150 goto end;
1151 }
1152
1153 for (i = 0; i < trace->listeners->len; i++) {
1154 struct listener_wrapper *listener =
1155 g_ptr_array_index(trace->listeners, i);
1156
1157 listener->listener(object, listener->data);
1158 }
1159 end:
1160 return 0;
1161 }
1162
1163 BT_HIDDEN
1164 struct bt_ctf_field_type *get_field_type(enum field_type_alias alias)
1165 {
1166 int ret;
1167 unsigned int alignment, size;
1168 struct bt_ctf_field_type *field_type = NULL;
1169
1170 if (alias >= NR_FIELD_TYPE_ALIAS) {
1171 goto end;
1172 }
1173
1174 alignment = field_type_aliases_alignments[alias];
1175 size = field_type_aliases_sizes[alias];
1176 field_type = bt_ctf_field_type_integer_create(size);
1177 ret = bt_ctf_field_type_set_alignment(field_type, alignment);
1178 if (ret) {
1179 BT_PUT(field_type);
1180 }
1181 end:
1182 return field_type;
1183 }
1184
1185 static
1186 void bt_ctf_trace_freeze(struct bt_ctf_trace *trace)
1187 {
1188 int i;
1189
1190 bt_ctf_field_type_freeze(trace->packet_header_type);
1191 bt_ctf_attributes_freeze(trace->environment);
1192
1193 for (i = 0; i < trace->clocks->len; i++) {
1194 struct bt_ctf_clock_class *clock_class =
1195 g_ptr_array_index(trace->clocks, i);
1196
1197 bt_ctf_clock_class_freeze(clock_class);
1198 }
1199
1200 trace->frozen = 1;
1201 }
1202
1203 static
1204 int init_trace_packet_header(struct bt_ctf_trace *trace)
1205 {
1206 int ret = 0;
1207 struct bt_ctf_field *magic = NULL, *uuid_array = NULL;
1208 struct bt_ctf_field_type *_uint32_t =
1209 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
1210 struct bt_ctf_field_type *_uint8_t =
1211 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
1212 struct bt_ctf_field_type *trace_packet_header_type =
1213 bt_ctf_field_type_structure_create();
1214 struct bt_ctf_field_type *uuid_array_type =
1215 bt_ctf_field_type_array_create(_uint8_t, 16);
1216
1217 if (!trace_packet_header_type || !uuid_array_type) {
1218 ret = -1;
1219 goto end;
1220 }
1221
1222 ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
1223 _uint32_t, "magic");
1224 if (ret) {
1225 goto end;
1226 }
1227
1228 ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
1229 uuid_array_type, "uuid");
1230 if (ret) {
1231 goto end;
1232 }
1233
1234 ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
1235 _uint32_t, "stream_id");
1236 if (ret) {
1237 goto end;
1238 }
1239
1240 ret = bt_ctf_trace_set_packet_header_type(trace,
1241 trace_packet_header_type);
1242 if (ret) {
1243 goto end;
1244 }
1245 end:
1246 bt_put(uuid_array_type);
1247 bt_put(_uint32_t);
1248 bt_put(_uint8_t);
1249 bt_put(magic);
1250 bt_put(uuid_array);
1251 bt_put(trace_packet_header_type);
1252 return ret;
1253 }
BabelTrace - Trace Format Babel Tower
This page took 0.056196 seconds and 4 git commands to generate.