projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lib: make trace IR API const-correct
[babeltrace.git] / plugins / ctf / common / metadata / ctf-meta.h
1 #ifndef _CTF_META_H
2 #define _CTF_META_H
3
4 /*
5 * Copyright 2018 - Philippe Proulx <pproulx@efficios.com>
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 */
17
18 #include <babeltrace/babeltrace.h>
19 #include <babeltrace/common-internal.h>
20 #include <babeltrace/assert-internal.h>
21 #include <glib.h>
22 #include <stdint.h>
23 #include <string.h>
24
25 enum ctf_field_class_type {
26 CTF_FIELD_CLASS_TYPE_INT,
27 CTF_FIELD_CLASS_TYPE_ENUM,
28 CTF_FIELD_CLASS_TYPE_FLOAT,
29 CTF_FIELD_CLASS_TYPE_STRING,
30 CTF_FIELD_CLASS_TYPE_STRUCT,
31 CTF_FIELD_CLASS_TYPE_ARRAY,
32 CTF_FIELD_CLASS_TYPE_SEQUENCE,
33 CTF_FIELD_CLASS_TYPE_VARIANT,
34 };
35
36 enum ctf_field_class_meaning {
37 CTF_FIELD_CLASS_MEANING_NONE,
38 CTF_FIELD_CLASS_MEANING_PACKET_BEGINNING_TIME,
39 CTF_FIELD_CLASS_MEANING_PACKET_END_TIME,
40 CTF_FIELD_CLASS_MEANING_EVENT_CLASS_ID,
41 CTF_FIELD_CLASS_MEANING_STREAM_CLASS_ID,
42 CTF_FIELD_CLASS_MEANING_DATA_STREAM_ID,
43 CTF_FIELD_CLASS_MEANING_MAGIC,
44 CTF_FIELD_CLASS_MEANING_PACKET_COUNTER_SNAPSHOT,
45 CTF_FIELD_CLASS_MEANING_DISC_EV_REC_COUNTER_SNAPSHOT,
46 CTF_FIELD_CLASS_MEANING_EXP_PACKET_TOTAL_SIZE,
47 CTF_FIELD_CLASS_MEANING_EXP_PACKET_CONTENT_SIZE,
48 CTF_FIELD_CLASS_MEANING_UUID,
49 };
50
51 enum ctf_byte_order {
52 CTF_BYTE_ORDER_DEFAULT,
53 CTF_BYTE_ORDER_LITTLE,
54 CTF_BYTE_ORDER_BIG,
55 };
56
57 enum ctf_encoding {
58 CTF_ENCODING_NONE,
59 CTF_ENCODING_UTF8,
60 };
61
62 struct ctf_field_class {
63 enum ctf_field_class_type type;
64 unsigned int alignment;
65 bool is_compound;
66 bool in_ir;
67
68 /* Weak, set during translation. NULL if `in_ir` is false below. */
69 struct bt_field_class *ir_fc;
70 };
71
72 struct ctf_field_class_bit_array {
73 struct ctf_field_class base;
74 enum ctf_byte_order byte_order;
75 unsigned int size;
76 };
77
78 struct ctf_field_class_int {
79 struct ctf_field_class_bit_array base;
80 enum ctf_field_class_meaning meaning;
81 bool is_signed;
82 enum bt_field_class_integer_preferred_display_base disp_base;
83 enum ctf_encoding encoding;
84 int64_t storing_index;
85
86 /* Owned by this */
87 struct bt_clock_class *mapped_clock_class;
88 };
89
90 struct ctf_range {
91 union {
92 uint64_t u;
93 int64_t i;
94 } lower;
95
96 union {
97 uint64_t u;
98 int64_t i;
99 } upper;
100 };
101
102 struct ctf_field_class_enum_mapping {
103 GString *label;
104 struct ctf_range range;
105 };
106
107 struct ctf_field_class_enum {
108 struct ctf_field_class_int base;
109
110 /* Array of `struct ctf_field_class_enum_mapping` */
111 GArray *mappings;
112 };
113
114 struct ctf_field_class_float {
115 struct ctf_field_class_bit_array base;
116 };
117
118 struct ctf_field_class_string {
119 struct ctf_field_class base;
120 enum ctf_encoding encoding;
121 };
122
123 struct ctf_named_field_class {
124 GString *name;
125
126 /* Owned by this */
127 struct ctf_field_class *fc;
128 };
129
130 struct ctf_field_class_struct {
131 struct ctf_field_class base;
132
133 /* Array of `struct ctf_named_field_class` */
134 GArray *members;
135 };
136
137 struct ctf_field_path {
138 enum bt_scope root;
139
140 /* Array of `int64_t` */
141 GArray *path;
142 };
143
144 struct ctf_field_class_variant_range {
145 struct ctf_range range;
146 uint64_t option_index;
147 };
148
149 struct ctf_field_class_variant {
150 struct ctf_field_class base;
151 GString *tag_ref;
152 struct ctf_field_path tag_path;
153 uint64_t stored_tag_index;
154
155 /* Array of `struct ctf_named_field_class` */
156 GArray *options;
157
158 /* Array of `struct ctf_field_class_variant_range` */
159 GArray *ranges;
160
161 /* Weak */
162 struct ctf_field_class_enum *tag_fc;
163 };
164
165 struct ctf_field_class_array_base {
166 struct ctf_field_class base;
167 struct ctf_field_class *elem_fc;
168 bool is_text;
169 };
170
171 struct ctf_field_class_array {
172 struct ctf_field_class_array_base base;
173 enum ctf_field_class_meaning meaning;
174 uint64_t length;
175 };
176
177 struct ctf_field_class_sequence {
178 struct ctf_field_class_array_base base;
179 GString *length_ref;
180 struct ctf_field_path length_path;
181 uint64_t stored_length_index;
182
183 /* Weak */
184 struct ctf_field_class_int *length_fc;
185 };
186
187 struct ctf_event_class {
188 GString *name;
189 uint64_t id;
190 GString *emf_uri;
191 enum bt_event_class_log_level log_level;
192 bool is_translated;
193
194 /* Owned by this */
195 struct ctf_field_class *spec_context_fc;
196
197 /* Owned by this */
198 struct ctf_field_class *payload_fc;
199
200 /* Weak, set during translation */
201 struct bt_event_class *ir_ec;
202 };
203
204 struct ctf_stream_class {
205 uint64_t id;
206 bool is_translated;
207
208 /* Owned by this */
209 struct ctf_field_class *packet_context_fc;
210
211 /* Owned by this */
212 struct ctf_field_class *event_header_fc;
213
214 /* Owned by this */
215 struct ctf_field_class *event_common_context_fc;
216
217 /* Array of `struct ctf_event_class *`, owned by this */
218 GPtrArray *event_classes;
219
220 /*
221 * Hash table mapping event class IDs to `struct ctf_event_class *`,
222 * weak.
223 */
224 GHashTable *event_classes_by_id;
225
226 /* Owned by this */
227 struct bt_clock_class *default_clock_class;
228
229 /* Weak, set during translation */
230 struct bt_stream_class *ir_sc;
231 };
232
233 enum ctf_trace_class_env_entry_type {
234 CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT,
235 CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR,
236 };
237
238 struct ctf_trace_class_env_entry {
239 enum ctf_trace_class_env_entry_type type;
240 GString *name;
241
242 struct {
243 int64_t i;
244 GString *str;
245 } value;
246 };
247
248 struct ctf_trace_class {
249 GString *name;
250 unsigned int major;
251 unsigned int minor;
252 uint8_t uuid[16];
253 bool is_uuid_set;
254 enum ctf_byte_order default_byte_order;
255
256 /* Owned by this */
257 struct ctf_field_class *packet_header_fc;
258
259 uint64_t stored_value_count;
260
261 /* Array of `struct bt_clock_class *` (owned by this) */
262 GPtrArray *clock_classes;
263
264 /* Array of `struct ctf_stream_class *` */
265 GPtrArray *stream_classes;
266
267 /* Array of `struct ctf_trace_class_env_entry` */
268 GArray *env_entries;
269
270 bool is_translated;
271
272 /* Weak, set during translation */
273 struct bt_trace *ir_tc;
274 };
275
276 static inline
277 void ctf_field_class_destroy(struct ctf_field_class *fc);
278
279 static inline
280 void _ctf_field_class_init(struct ctf_field_class *fc,
281 enum ctf_field_class_type type, unsigned int alignment)
282 {
283 BT_ASSERT(fc);
284 fc->type = type;
285 fc->alignment = alignment;
286 fc->in_ir = false;
287 }
288
289 static inline
290 void _ctf_field_class_bit_array_init(struct ctf_field_class_bit_array *fc,
291 enum ctf_field_class_type type)
292 {
293 _ctf_field_class_init((void *) fc, type, 1);
294 }
295
296 static inline
297 void _ctf_field_class_int_init(struct ctf_field_class_int *fc,
298 enum ctf_field_class_type type)
299 {
300 _ctf_field_class_bit_array_init((void *) fc, type);
301 fc->meaning = CTF_FIELD_CLASS_MEANING_NONE;
302 fc->storing_index = -1;
303 }
304
305 static inline
306 void ctf_field_path_init(struct ctf_field_path *field_path)
307 {
308 BT_ASSERT(field_path);
309 field_path->path = g_array_new(FALSE, TRUE, sizeof(int64_t));
310 BT_ASSERT(field_path->path);
311 }
312
313 static inline
314 void ctf_field_path_fini(struct ctf_field_path *field_path)
315 {
316 BT_ASSERT(field_path);
317
318 if (field_path->path) {
319 g_array_free(field_path->path, TRUE);
320 }
321 }
322
323 static inline
324 void _ctf_named_field_class_init(struct ctf_named_field_class *named_fc)
325 {
326 BT_ASSERT(named_fc);
327 named_fc->name = g_string_new(NULL);
328 BT_ASSERT(named_fc->name);
329 }
330
331 static inline
332 void _ctf_named_field_class_fini(struct ctf_named_field_class *named_fc)
333 {
334 BT_ASSERT(named_fc);
335
336 if (named_fc->name) {
337 g_string_free(named_fc->name, TRUE);
338 }
339
340 ctf_field_class_destroy(named_fc->fc);
341 }
342
343 static inline
344 void _ctf_field_class_enum_mapping_init(
345 struct ctf_field_class_enum_mapping *mapping)
346 {
347 BT_ASSERT(mapping);
348 mapping->label = g_string_new(NULL);
349 BT_ASSERT(mapping->label);
350 }
351
352 static inline
353 void _ctf_field_class_enum_mapping_fini(
354 struct ctf_field_class_enum_mapping *mapping)
355 {
356 BT_ASSERT(mapping);
357
358 if (mapping->label) {
359 g_string_free(mapping->label, TRUE);
360 }
361 }
362
363 static inline
364 struct ctf_field_class_int *ctf_field_class_int_create(void)
365 {
366 struct ctf_field_class_int *fc = g_new0(struct ctf_field_class_int, 1);
367
368 BT_ASSERT(fc);
369 _ctf_field_class_int_init(fc, CTF_FIELD_CLASS_TYPE_INT);
370 return fc;
371 }
372
373 static inline
374 struct ctf_field_class_float *ctf_field_class_float_create(void)
375 {
376 struct ctf_field_class_float *fc =
377 g_new0(struct ctf_field_class_float, 1);
378
379 BT_ASSERT(fc);
380 _ctf_field_class_bit_array_init((void *) fc, CTF_FIELD_CLASS_TYPE_FLOAT);
381 return fc;
382 }
383
384 static inline
385 struct ctf_field_class_string *ctf_field_class_string_create(void)
386 {
387 struct ctf_field_class_string *fc =
388 g_new0(struct ctf_field_class_string, 1);
389
390 BT_ASSERT(fc);
391 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_STRING, 8);
392 return fc;
393 }
394
395 static inline
396 struct ctf_field_class_enum *ctf_field_class_enum_create(void)
397 {
398 struct ctf_field_class_enum *fc = g_new0(struct ctf_field_class_enum, 1);
399
400 BT_ASSERT(fc);
401 _ctf_field_class_int_init((void *) fc, CTF_FIELD_CLASS_TYPE_ENUM);
402 fc->mappings = g_array_new(FALSE, TRUE,
403 sizeof(struct ctf_field_class_enum_mapping));
404 BT_ASSERT(fc->mappings);
405 return fc;
406 }
407
408 static inline
409 struct ctf_field_class_struct *ctf_field_class_struct_create(void)
410 {
411 struct ctf_field_class_struct *fc =
412 g_new0(struct ctf_field_class_struct, 1);
413
414 BT_ASSERT(fc);
415 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_STRUCT, 1);
416 fc->members = g_array_new(FALSE, TRUE,
417 sizeof(struct ctf_named_field_class));
418 BT_ASSERT(fc->members);
419 fc->base.is_compound = true;
420 return fc;
421 }
422
423 static inline
424 struct ctf_field_class_variant *ctf_field_class_variant_create(void)
425 {
426 struct ctf_field_class_variant *fc =
427 g_new0(struct ctf_field_class_variant, 1);
428
429 BT_ASSERT(fc);
430 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_VARIANT, 1);
431 fc->options = g_array_new(FALSE, TRUE,
432 sizeof(struct ctf_named_field_class));
433 BT_ASSERT(fc->options);
434 fc->ranges = g_array_new(FALSE, TRUE,
435 sizeof(struct ctf_field_class_variant_range));
436 BT_ASSERT(fc->ranges);
437 fc->tag_ref = g_string_new(NULL);
438 BT_ASSERT(fc->tag_ref);
439 ctf_field_path_init(&fc->tag_path);
440 fc->base.is_compound = true;
441 return fc;
442 }
443
444 static inline
445 struct ctf_field_class_array *ctf_field_class_array_create(void)
446 {
447 struct ctf_field_class_array *fc =
448 g_new0(struct ctf_field_class_array, 1);
449
450 BT_ASSERT(fc);
451 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_ARRAY, 1);
452 fc->base.base.is_compound = true;
453 return fc;
454 }
455
456 static inline
457 struct ctf_field_class_sequence *ctf_field_class_sequence_create(void)
458 {
459 struct ctf_field_class_sequence *fc =
460 g_new0(struct ctf_field_class_sequence, 1);
461
462 BT_ASSERT(fc);
463 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_SEQUENCE, 1);
464 fc->length_ref = g_string_new(NULL);
465 BT_ASSERT(fc->length_ref);
466 ctf_field_path_init(&fc->length_path);
467 fc->base.base.is_compound = true;
468 return fc;
469 }
470
471 static inline
472 void _ctf_field_class_int_destroy(struct ctf_field_class_int *fc)
473 {
474 BT_ASSERT(fc);
475 bt_object_put_ref(fc->mapped_clock_class);
476 g_free(fc);
477 }
478
479 static inline
480 void _ctf_field_class_enum_destroy(struct ctf_field_class_enum *fc)
481 {
482 BT_ASSERT(fc);
483 bt_object_put_ref(fc->base.mapped_clock_class);
484
485 if (fc->mappings) {
486 uint64_t i;
487
488 for (i = 0; i < fc->mappings->len; i++) {
489 struct ctf_field_class_enum_mapping *mapping =
490 &g_array_index(fc->mappings,
491 struct ctf_field_class_enum_mapping, i);
492
493 _ctf_field_class_enum_mapping_fini(mapping);
494 }
495
496 g_array_free(fc->mappings, TRUE);
497 }
498
499 g_free(fc);
500 }
501
502 static inline
503 void _ctf_field_class_float_destroy(struct ctf_field_class_float *fc)
504 {
505 BT_ASSERT(fc);
506 g_free(fc);
507 }
508
509 static inline
510 void _ctf_field_class_string_destroy(struct ctf_field_class_string *fc)
511 {
512 BT_ASSERT(fc);
513 g_free(fc);
514 }
515
516 static inline
517 void _ctf_field_class_struct_destroy(struct ctf_field_class_struct *fc)
518 {
519 BT_ASSERT(fc);
520
521 if (fc->members) {
522 uint64_t i;
523
524 for (i = 0; i < fc->members->len; i++) {
525 struct ctf_named_field_class *named_fc =
526 &g_array_index(fc->members,
527 struct ctf_named_field_class, i);
528
529 _ctf_named_field_class_fini(named_fc);
530 }
531
532 g_array_free(fc->members, TRUE);
533 }
534
535 g_free(fc);
536 }
537
538 static inline
539 void _ctf_field_class_array_base_fini(struct ctf_field_class_array_base *fc)
540 {
541 BT_ASSERT(fc);
542 ctf_field_class_destroy(fc->elem_fc);
543 }
544
545 static inline
546 void _ctf_field_class_array_destroy(struct ctf_field_class_array *fc)
547 {
548 BT_ASSERT(fc);
549 _ctf_field_class_array_base_fini((void *) fc);
550 g_free(fc);
551 }
552
553 static inline
554 void _ctf_field_class_sequence_destroy(struct ctf_field_class_sequence *fc)
555 {
556 BT_ASSERT(fc);
557 _ctf_field_class_array_base_fini((void *) fc);
558
559 if (fc->length_ref) {
560 g_string_free(fc->length_ref, TRUE);
561 }
562
563 ctf_field_path_fini(&fc->length_path);
564 g_free(fc);
565 }
566
567 static inline
568 void _ctf_field_class_variant_destroy(struct ctf_field_class_variant *fc)
569 {
570 BT_ASSERT(fc);
571
572 if (fc->options) {
573 uint64_t i;
574
575 for (i = 0; i < fc->options->len; i++) {
576 struct ctf_named_field_class *named_fc =
577 &g_array_index(fc->options,
578 struct ctf_named_field_class, i);
579
580 _ctf_named_field_class_fini(named_fc);
581 }
582
583 g_array_free(fc->options, TRUE);
584 }
585
586 if (fc->ranges) {
587 g_array_free(fc->ranges, TRUE);
588 }
589
590 if (fc->tag_ref) {
591 g_string_free(fc->tag_ref, TRUE);
592 }
593
594 ctf_field_path_fini(&fc->tag_path);
595 g_free(fc);
596 }
597
598 static inline
599 void ctf_field_class_destroy(struct ctf_field_class *fc)
600 {
601 if (!fc) {
602 return;
603 }
604
605 switch (fc->type) {
606 case CTF_FIELD_CLASS_TYPE_INT:
607 _ctf_field_class_int_destroy((void *) fc);
608 break;
609 case CTF_FIELD_CLASS_TYPE_ENUM:
610 _ctf_field_class_enum_destroy((void *) fc);
611 break;
612 case CTF_FIELD_CLASS_TYPE_FLOAT:
613 _ctf_field_class_float_destroy((void *) fc);
614 break;
615 case CTF_FIELD_CLASS_TYPE_STRING:
616 _ctf_field_class_string_destroy((void *) fc);
617 break;
618 case CTF_FIELD_CLASS_TYPE_STRUCT:
619 _ctf_field_class_struct_destroy((void *) fc);
620 break;
621 case CTF_FIELD_CLASS_TYPE_ARRAY:
622 _ctf_field_class_array_destroy((void *) fc);
623 break;
624 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
625 _ctf_field_class_sequence_destroy((void *) fc);
626 break;
627 case CTF_FIELD_CLASS_TYPE_VARIANT:
628 _ctf_field_class_variant_destroy((void *) fc);
629 break;
630 default:
631 abort();
632 }
633 }
634
635 static inline
636 void ctf_field_class_enum_append_mapping(struct ctf_field_class_enum *fc,
637 const char *label, uint64_t u_lower, uint64_t u_upper)
638 {
639 struct ctf_field_class_enum_mapping *mapping;
640
641 BT_ASSERT(fc);
642 BT_ASSERT(label);
643 g_array_set_size(fc->mappings, fc->mappings->len + 1);
644
645 mapping = &g_array_index(fc->mappings,
646 struct ctf_field_class_enum_mapping, fc->mappings->len - 1);
647 _ctf_field_class_enum_mapping_init(mapping);
648 g_string_assign(mapping->label, label);
649 mapping->range.lower.u = u_lower;
650 mapping->range.upper.u = u_upper;
651 }
652
653 static inline
654 struct ctf_field_class_enum_mapping *ctf_field_class_enum_borrow_mapping_by_index(
655 struct ctf_field_class_enum *fc, uint64_t index)
656 {
657 BT_ASSERT(fc);
658 BT_ASSERT(index < fc->mappings->len);
659 return &g_array_index(fc->mappings, struct ctf_field_class_enum_mapping,
660 index);
661 }
662
663 static inline
664 struct ctf_named_field_class *ctf_field_class_struct_borrow_member_by_index(
665 struct ctf_field_class_struct *fc, uint64_t index)
666 {
667 BT_ASSERT(fc);
668 BT_ASSERT(index < fc->members->len);
669 return &g_array_index(fc->members, struct ctf_named_field_class,
670 index);
671 }
672
673 static inline
674 struct ctf_named_field_class *ctf_field_class_struct_borrow_member_by_name(
675 struct ctf_field_class_struct *fc, const char *name)
676 {
677 uint64_t i;
678 struct ctf_named_field_class *ret_named_fc = NULL;
679
680 BT_ASSERT(fc);
681 BT_ASSERT(name);
682
683 for (i = 0; i < fc->members->len; i++) {
684 struct ctf_named_field_class *named_fc =
685 ctf_field_class_struct_borrow_member_by_index(fc, i);
686
687 if (strcmp(name, named_fc->name->str) == 0) {
688 ret_named_fc = named_fc;
689 goto end;
690 }
691 }
692
693 end:
694 return ret_named_fc;
695 }
696
697 static inline
698 struct ctf_field_class *ctf_field_class_struct_borrow_member_field_class_by_name(
699 struct ctf_field_class_struct *struct_fc, const char *name)
700 {
701 struct ctf_named_field_class *named_fc = NULL;
702 struct ctf_field_class *fc = NULL;
703
704 if (!struct_fc) {
705 goto end;
706 }
707
708 named_fc = ctf_field_class_struct_borrow_member_by_name(struct_fc, name);
709 if (!named_fc) {
710 goto end;
711 }
712
713 fc = named_fc->fc;
714
715 end:
716 return fc;
717 }
718
719 static inline
720 struct ctf_field_class_int *
721 ctf_field_class_struct_borrow_member_int_field_class_by_name(
722 struct ctf_field_class_struct *struct_fc, const char *name)
723 {
724 struct ctf_field_class_int *int_fc = NULL;
725
726 int_fc = (void *)
727 ctf_field_class_struct_borrow_member_field_class_by_name(
728 struct_fc, name);
729 if (!int_fc) {
730 goto end;
731 }
732
733 if (int_fc->base.base.type != CTF_FIELD_CLASS_TYPE_INT &&
734 int_fc->base.base.type != CTF_FIELD_CLASS_TYPE_ENUM) {
735 int_fc = NULL;
736 goto end;
737 }
738
739 end:
740 return int_fc;
741 }
742
743
744 static inline
745 void ctf_field_class_struct_append_member(struct ctf_field_class_struct *fc,
746 const char *name, struct ctf_field_class *member_fc)
747 {
748 struct ctf_named_field_class *named_fc;
749
750 BT_ASSERT(fc);
751 BT_ASSERT(name);
752 g_array_set_size(fc->members, fc->members->len + 1);
753
754 named_fc = &g_array_index(fc->members, struct ctf_named_field_class,
755 fc->members->len - 1);
756 _ctf_named_field_class_init(named_fc);
757 g_string_assign(named_fc->name, name);
758 named_fc->fc = member_fc;
759
760 if (member_fc->alignment > fc->base.alignment) {
761 fc->base.alignment = member_fc->alignment;
762 }
763 }
764
765 static inline
766 struct ctf_named_field_class *ctf_field_class_variant_borrow_option_by_index(
767 struct ctf_field_class_variant *fc, uint64_t index)
768 {
769 BT_ASSERT(fc);
770 BT_ASSERT(index < fc->options->len);
771 return &g_array_index(fc->options, struct ctf_named_field_class,
772 index);
773 }
774
775 static inline
776 struct ctf_named_field_class *ctf_field_class_variant_borrow_option_by_name(
777 struct ctf_field_class_variant *fc, const char *name)
778 {
779 uint64_t i;
780 struct ctf_named_field_class *ret_named_fc = NULL;
781
782 BT_ASSERT(fc);
783 BT_ASSERT(name);
784
785 for (i = 0; i < fc->options->len; i++) {
786 struct ctf_named_field_class *named_fc =
787 ctf_field_class_variant_borrow_option_by_index(fc, i);
788
789 if (strcmp(name, named_fc->name->str) == 0) {
790 ret_named_fc = named_fc;
791 goto end;
792 }
793 }
794
795 end:
796 return ret_named_fc;
797 }
798
799 static inline
800 struct ctf_field_class_variant_range *
801 ctf_field_class_variant_borrow_range_by_index(
802 struct ctf_field_class_variant *fc, uint64_t index)
803 {
804 BT_ASSERT(fc);
805 BT_ASSERT(index < fc->ranges->len);
806 return &g_array_index(fc->ranges, struct ctf_field_class_variant_range,
807 index);
808 }
809
810 static inline
811 void ctf_field_class_variant_append_option(struct ctf_field_class_variant *fc,
812 const char *name, struct ctf_field_class *option_fc)
813 {
814 struct ctf_named_field_class *named_fc;
815
816 BT_ASSERT(fc);
817 BT_ASSERT(name);
818 g_array_set_size(fc->options, fc->options->len + 1);
819
820 named_fc = &g_array_index(fc->options, struct ctf_named_field_class,
821 fc->options->len - 1);
822 _ctf_named_field_class_init(named_fc);
823 g_string_assign(named_fc->name, name);
824 named_fc->fc = option_fc;
825 }
826
827 static inline
828 void ctf_field_class_variant_set_tag_field_class(
829 struct ctf_field_class_variant *fc,
830 struct ctf_field_class_enum *tag_fc)
831 {
832 uint64_t option_i;
833
834 BT_ASSERT(fc);
835 BT_ASSERT(tag_fc);
836 fc->tag_fc = tag_fc;
837
838 for (option_i = 0; option_i < fc->options->len; option_i++) {
839 uint64_t mapping_i;
840 struct ctf_named_field_class *named_fc =
841 ctf_field_class_variant_borrow_option_by_index(
842 fc, option_i);
843
844 for (mapping_i = 0; mapping_i < tag_fc->mappings->len;
845 mapping_i++) {
846 struct ctf_field_class_enum_mapping *mapping =
847 ctf_field_class_enum_borrow_mapping_by_index(
848 tag_fc, mapping_i);
849
850 if (strcmp(named_fc->name->str,
851 mapping->label->str) == 0) {
852 struct ctf_field_class_variant_range range;
853
854 range.range = mapping->range;
855 range.option_index = option_i;
856 g_array_append_val(fc->ranges, range);
857 }
858 }
859 }
860 }
861
862 static inline
863 struct ctf_field_class *ctf_field_class_compound_borrow_field_class_by_index(
864 struct ctf_field_class *comp_fc, uint64_t index)
865 {
866 struct ctf_field_class *fc = NULL;
867
868 switch (comp_fc->type) {
869 case CTF_FIELD_CLASS_TYPE_STRUCT:
870 {
871 struct ctf_named_field_class *named_fc =
872 ctf_field_class_struct_borrow_member_by_index(
873 (void *) comp_fc, index);
874
875 BT_ASSERT(named_fc);
876 fc = named_fc->fc;
877 break;
878 }
879 case CTF_FIELD_CLASS_TYPE_VARIANT:
880 {
881 struct ctf_named_field_class *named_fc =
882 ctf_field_class_variant_borrow_option_by_index(
883 (void *) comp_fc, index);
884
885 BT_ASSERT(named_fc);
886 fc = named_fc->fc;
887 break;
888 }
889 case CTF_FIELD_CLASS_TYPE_ARRAY:
890 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
891 {
892 struct ctf_field_class_array_base *array_fc = (void *) comp_fc;
893
894 fc = array_fc->elem_fc;
895 break;
896 }
897 default:
898 break;
899 }
900
901 return fc;
902 }
903
904 static inline
905 uint64_t ctf_field_class_compound_get_field_class_count(struct ctf_field_class *fc)
906 {
907 uint64_t field_count;
908
909 switch (fc->type) {
910 case CTF_FIELD_CLASS_TYPE_STRUCT:
911 {
912 struct ctf_field_class_struct *struct_fc = (void *) fc;
913
914 field_count = struct_fc->members->len;
915 break;
916 }
917 case CTF_FIELD_CLASS_TYPE_VARIANT:
918 {
919 struct ctf_field_class_variant *var_fc = (void *) fc;
920
921 field_count = var_fc->options->len;
922 break;
923 }
924 case CTF_FIELD_CLASS_TYPE_ARRAY:
925 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
926 /*
927 * Array and sequence types always contain a single
928 * member (the element type).
929 */
930 field_count = 1;
931 break;
932 default:
933 abort();
934 }
935
936 return field_count;
937 }
938
939 static inline
940 int64_t ctf_field_class_compound_get_field_class_index_from_name(
941 struct ctf_field_class *fc, const char *name)
942 {
943 int64_t ret_index = -1;
944 uint64_t i;
945
946 switch (fc->type) {
947 case CTF_FIELD_CLASS_TYPE_STRUCT:
948 {
949 struct ctf_field_class_struct *struct_fc = (void *) fc;
950
951 for (i = 0; i < struct_fc->members->len; i++) {
952 struct ctf_named_field_class *named_fc =
953 ctf_field_class_struct_borrow_member_by_index(
954 struct_fc, i);
955
956 if (strcmp(name, named_fc->name->str) == 0) {
957 ret_index = (int64_t) i;
958 goto end;
959 }
960 }
961
962 break;
963 }
964 case CTF_FIELD_CLASS_TYPE_VARIANT:
965 {
966 struct ctf_field_class_variant *var_fc = (void *) fc;
967
968 for (i = 0; i < var_fc->options->len; i++) {
969 struct ctf_named_field_class *named_fc =
970 ctf_field_class_variant_borrow_option_by_index(
971 var_fc, i);
972
973 if (strcmp(name, named_fc->name->str) == 0) {
974 ret_index = (int64_t) i;
975 goto end;
976 }
977 }
978
979 break;
980 }
981 default:
982 break;
983 }
984
985 end:
986 return ret_index;
987 }
988
989 static inline
990 void ctf_field_path_append_index(struct ctf_field_path *fp, int64_t index)
991 {
992 BT_ASSERT(fp);
993 g_array_append_val(fp->path, index);
994 }
995
996 static inline
997 int64_t ctf_field_path_borrow_index_by_index(struct ctf_field_path *fp,
998 uint64_t index)
999 {
1000 BT_ASSERT(fp);
1001 BT_ASSERT(index < fp->path->len);
1002 return g_array_index(fp->path, int64_t, index);
1003 }
1004
1005 static inline
1006 void ctf_field_path_clear(struct ctf_field_path *fp)
1007 {
1008 BT_ASSERT(fp);
1009 g_array_set_size(fp->path, 0);
1010 }
1011
1012 static inline
1013 GString *ctf_field_path_string(struct ctf_field_path *path)
1014 {
1015 GString *str = g_string_new(NULL);
1016 uint64_t i;
1017
1018 BT_ASSERT(path);
1019
1020 if (!str) {
1021 goto end;
1022 }
1023
1024 g_string_append_printf(str, "[%s", bt_common_scope_string(
1025 path->root));
1026
1027 for (i = 0; i < path->path->len; i++) {
1028 g_string_append_printf(str, ", %" PRId64,
1029 ctf_field_path_borrow_index_by_index(path, i));
1030 }
1031
1032 g_string_append(str, "]");
1033
1034 end:
1035 return str;
1036 }
1037
1038 static inline
1039 struct ctf_field_class *ctf_field_path_borrow_field_class(
1040 struct ctf_field_path *field_path,
1041 struct ctf_trace_class *tc,
1042 struct ctf_stream_class *sc,
1043 struct ctf_event_class *ec)
1044 {
1045 uint64_t i;
1046 struct ctf_field_class *fc;
1047
1048 switch (field_path->root) {
1049 case BT_SCOPE_PACKET_HEADER:
1050 fc = tc->packet_header_fc;
1051 break;
1052 case BT_SCOPE_PACKET_CONTEXT:
1053 fc = sc->packet_context_fc;
1054 break;
1055 case BT_SCOPE_EVENT_HEADER:
1056 fc = sc->event_header_fc;
1057 break;
1058 case BT_SCOPE_EVENT_COMMON_CONTEXT:
1059 fc = sc->event_common_context_fc;
1060 break;
1061 case BT_SCOPE_EVENT_SPECIFIC_CONTEXT:
1062 fc = ec->spec_context_fc;
1063 break;
1064 case BT_SCOPE_EVENT_PAYLOAD:
1065 fc = ec->payload_fc;
1066 break;
1067 default:
1068 abort();
1069 }
1070
1071 BT_ASSERT(fc);
1072
1073 for (i = 0; i < field_path->path->len; i++) {
1074 int64_t child_index =
1075 ctf_field_path_borrow_index_by_index(field_path, i);
1076 struct ctf_field_class *child_fc =
1077 ctf_field_class_compound_borrow_field_class_by_index(
1078 fc, child_index);
1079 BT_ASSERT(child_fc);
1080 fc = child_fc;
1081 }
1082
1083 BT_ASSERT(fc);
1084 return fc;
1085 }
1086
1087 static inline
1088 struct ctf_field_class *ctf_field_class_copy(struct ctf_field_class *fc);
1089
1090 static inline
1091 void ctf_field_class_bit_array_copy_content(
1092 struct ctf_field_class_bit_array *dst_fc,
1093 struct ctf_field_class_bit_array *src_fc)
1094 {
1095 BT_ASSERT(dst_fc);
1096 BT_ASSERT(src_fc);
1097 dst_fc->byte_order = src_fc->byte_order;
1098 dst_fc->size = src_fc->size;
1099 }
1100
1101 static inline
1102 void ctf_field_class_int_copy_content(
1103 struct ctf_field_class_int *dst_fc,
1104 struct ctf_field_class_int *src_fc)
1105 {
1106 ctf_field_class_bit_array_copy_content((void *) dst_fc, (void *) src_fc);
1107 dst_fc->meaning = src_fc->meaning;
1108 dst_fc->is_signed = src_fc->is_signed;
1109 dst_fc->disp_base = src_fc->disp_base;
1110 dst_fc->encoding = src_fc->encoding;
1111 dst_fc->mapped_clock_class = src_fc->mapped_clock_class;
1112 bt_object_get_ref(dst_fc->mapped_clock_class);
1113 dst_fc->storing_index = src_fc->storing_index;
1114 }
1115
1116 static inline
1117 struct ctf_field_class_int *_ctf_field_class_int_copy(
1118 struct ctf_field_class_int *fc)
1119 {
1120 struct ctf_field_class_int *copy_fc = ctf_field_class_int_create();
1121
1122 BT_ASSERT(copy_fc);
1123 ctf_field_class_int_copy_content(copy_fc, fc);
1124 return copy_fc;
1125 }
1126
1127 static inline
1128 struct ctf_field_class_enum *_ctf_field_class_enum_copy(
1129 struct ctf_field_class_enum *fc)
1130 {
1131 struct ctf_field_class_enum *copy_fc = ctf_field_class_enum_create();
1132 uint64_t i;
1133
1134 BT_ASSERT(copy_fc);
1135 ctf_field_class_int_copy_content((void *) copy_fc, (void *) fc);
1136
1137 for (i = 0; i < fc->mappings->len; i++) {
1138 struct ctf_field_class_enum_mapping *mapping =
1139 &g_array_index(fc->mappings,
1140 struct ctf_field_class_enum_mapping, i);
1141
1142 ctf_field_class_enum_append_mapping(copy_fc, mapping->label->str,
1143 mapping->range.lower.u, mapping->range.upper.u);
1144 }
1145
1146 return copy_fc;
1147 }
1148
1149 static inline
1150 struct ctf_field_class_float *_ctf_field_class_float_copy(
1151 struct ctf_field_class_float *fc)
1152 {
1153 struct ctf_field_class_float *copy_fc = ctf_field_class_float_create();
1154
1155 BT_ASSERT(copy_fc);
1156 ctf_field_class_bit_array_copy_content((void *) copy_fc, (void *) fc);
1157 return copy_fc;
1158 }
1159
1160 static inline
1161 struct ctf_field_class_string *_ctf_field_class_string_copy(
1162 struct ctf_field_class_string *fc)
1163 {
1164 struct ctf_field_class_string *copy_fc = ctf_field_class_string_create();
1165
1166 BT_ASSERT(copy_fc);
1167 return copy_fc;
1168 }
1169
1170 static inline
1171 struct ctf_field_class_struct *_ctf_field_class_struct_copy(
1172 struct ctf_field_class_struct *fc)
1173 {
1174 struct ctf_field_class_struct *copy_fc = ctf_field_class_struct_create();
1175 uint64_t i;
1176
1177 BT_ASSERT(copy_fc);
1178
1179 for (i = 0; i < fc->members->len; i++) {
1180 struct ctf_named_field_class *named_fc =
1181 &g_array_index(fc->members,
1182 struct ctf_named_field_class, i);
1183
1184 ctf_field_class_struct_append_member(copy_fc,
1185 named_fc->name->str,
1186 ctf_field_class_copy(named_fc->fc));
1187 }
1188
1189 return copy_fc;
1190 }
1191
1192 static inline
1193 void ctf_field_path_copy_content(struct ctf_field_path *dst_fp,
1194 struct ctf_field_path *src_fp)
1195 {
1196 uint64_t i;
1197
1198 BT_ASSERT(dst_fp);
1199 BT_ASSERT(src_fp);
1200 dst_fp->root = src_fp->root;
1201 ctf_field_path_clear(dst_fp);
1202
1203 for (i = 0; i < src_fp->path->len; i++) {
1204 int64_t index = ctf_field_path_borrow_index_by_index(
1205 src_fp, i);
1206
1207 ctf_field_path_append_index(dst_fp, index);
1208 }
1209 }
1210
1211 static inline
1212 struct ctf_field_class_variant *_ctf_field_class_variant_copy(
1213 struct ctf_field_class_variant *fc)
1214 {
1215 struct ctf_field_class_variant *copy_fc =
1216 ctf_field_class_variant_create();
1217 uint64_t i;
1218
1219 BT_ASSERT(copy_fc);
1220
1221 for (i = 0; i < fc->options->len; i++) {
1222 struct ctf_named_field_class *named_fc =
1223 &g_array_index(fc->options,
1224 struct ctf_named_field_class, i);
1225
1226 ctf_field_class_variant_append_option(copy_fc,
1227 named_fc->name->str,
1228 ctf_field_class_copy(named_fc->fc));
1229 }
1230
1231 for (i = 0; i < fc->ranges->len; i++) {
1232 struct ctf_field_class_variant_range *range =
1233 &g_array_index(fc->ranges,
1234 struct ctf_field_class_variant_range, i);
1235
1236 g_array_append_val(copy_fc->ranges, *range);
1237 }
1238
1239 ctf_field_path_copy_content(&copy_fc->tag_path, &fc->tag_path);
1240 g_string_assign(copy_fc->tag_ref, fc->tag_ref->str);
1241 copy_fc->stored_tag_index = fc->stored_tag_index;
1242 return copy_fc;
1243 }
1244
1245 static inline
1246 void ctf_field_class_array_base_copy_content(
1247 struct ctf_field_class_array_base *dst_fc,
1248 struct ctf_field_class_array_base *src_fc)
1249 {
1250 BT_ASSERT(dst_fc);
1251 BT_ASSERT(src_fc);
1252 dst_fc->elem_fc = ctf_field_class_copy(src_fc->elem_fc);
1253 dst_fc->is_text = src_fc->is_text;
1254 }
1255
1256 static inline
1257 struct ctf_field_class_array *_ctf_field_class_array_copy(
1258 struct ctf_field_class_array *fc)
1259 {
1260 struct ctf_field_class_array *copy_fc = ctf_field_class_array_create();
1261
1262 BT_ASSERT(copy_fc);
1263 ctf_field_class_array_base_copy_content((void *) copy_fc, (void *) fc);
1264 copy_fc->length = fc->length;
1265 return copy_fc;
1266 }
1267
1268 static inline
1269 struct ctf_field_class_sequence *_ctf_field_class_sequence_copy(
1270 struct ctf_field_class_sequence *fc)
1271 {
1272 struct ctf_field_class_sequence *copy_fc =
1273 ctf_field_class_sequence_create();
1274
1275 BT_ASSERT(copy_fc);
1276 ctf_field_class_array_base_copy_content((void *) copy_fc, (void *) fc);
1277 ctf_field_path_copy_content(&copy_fc->length_path, &fc->length_path);
1278 g_string_assign(copy_fc->length_ref, fc->length_ref->str);
1279 copy_fc->stored_length_index = fc->stored_length_index;
1280 return copy_fc;
1281 }
1282
1283 static inline
1284 struct ctf_field_class *ctf_field_class_copy(struct ctf_field_class *fc)
1285 {
1286 struct ctf_field_class *copy_fc = NULL;
1287
1288 if (!fc) {
1289 goto end;
1290 }
1291
1292 /*
1293 * Translation should not have happened yet.
1294 */
1295 BT_ASSERT(!fc->ir_fc);
1296
1297 switch (fc->type) {
1298 case CTF_FIELD_CLASS_TYPE_INT:
1299 copy_fc = (void *) _ctf_field_class_int_copy((void *) fc);
1300 break;
1301 case CTF_FIELD_CLASS_TYPE_ENUM:
1302 copy_fc = (void *) _ctf_field_class_enum_copy((void *) fc);
1303 break;
1304 case CTF_FIELD_CLASS_TYPE_FLOAT:
1305 copy_fc = (void *) _ctf_field_class_float_copy((void *) fc);
1306 break;
1307 case CTF_FIELD_CLASS_TYPE_STRING:
1308 copy_fc = (void *) _ctf_field_class_string_copy((void *) fc);
1309 break;
1310 case CTF_FIELD_CLASS_TYPE_STRUCT:
1311 copy_fc = (void *) _ctf_field_class_struct_copy((void *) fc);
1312 break;
1313 case CTF_FIELD_CLASS_TYPE_ARRAY:
1314 copy_fc = (void *) _ctf_field_class_array_copy((void *) fc);
1315 break;
1316 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
1317 copy_fc = (void *) _ctf_field_class_sequence_copy((void *) fc);
1318 break;
1319 case CTF_FIELD_CLASS_TYPE_VARIANT:
1320 copy_fc = (void *) _ctf_field_class_variant_copy((void *) fc);
1321 break;
1322 default:
1323 abort();
1324 }
1325
1326 copy_fc->type = fc->type;
1327 copy_fc->alignment = fc->alignment;
1328 copy_fc->in_ir = fc->in_ir;
1329
1330 end:
1331 return copy_fc;
1332 }
1333
1334 static inline
1335 struct ctf_event_class *ctf_event_class_create(void)
1336 {
1337 struct ctf_event_class *ec = g_new0(struct ctf_event_class, 1);
1338
1339 BT_ASSERT(ec);
1340 ec->name = g_string_new(NULL);
1341 BT_ASSERT(ec->name);
1342 ec->emf_uri = g_string_new(NULL);
1343 BT_ASSERT(ec->emf_uri);
1344 ec->log_level = -1;
1345 return ec;
1346 }
1347
1348 static inline
1349 void ctf_event_class_destroy(struct ctf_event_class *ec)
1350 {
1351 if (!ec) {
1352 return;
1353 }
1354
1355 if (ec->name) {
1356 g_string_free(ec->name, TRUE);
1357 }
1358
1359 if (ec->emf_uri) {
1360 g_string_free(ec->emf_uri, TRUE);
1361 }
1362
1363 ctf_field_class_destroy(ec->spec_context_fc);
1364 ctf_field_class_destroy(ec->payload_fc);
1365 g_free(ec);
1366 }
1367
1368 static inline
1369 struct ctf_stream_class *ctf_stream_class_create(void)
1370 {
1371 struct ctf_stream_class *sc = g_new0(struct ctf_stream_class, 1);
1372
1373 BT_ASSERT(sc);
1374 sc->event_classes = g_ptr_array_new_with_free_func(
1375 (GDestroyNotify) ctf_event_class_destroy);
1376 BT_ASSERT(sc->event_classes);
1377 sc->event_classes_by_id = g_hash_table_new(g_direct_hash,
1378 g_direct_equal);
1379 BT_ASSERT(sc->event_classes_by_id);
1380 return sc;
1381 }
1382
1383 static inline
1384 void ctf_stream_class_destroy(struct ctf_stream_class *sc)
1385 {
1386 if (!sc) {
1387 return;
1388 }
1389
1390 if (sc->event_classes) {
1391 g_ptr_array_free(sc->event_classes, TRUE);
1392 }
1393
1394 if (sc->event_classes_by_id) {
1395 g_hash_table_destroy(sc->event_classes_by_id);
1396 }
1397
1398 ctf_field_class_destroy(sc->packet_context_fc);
1399 ctf_field_class_destroy(sc->event_header_fc);
1400 ctf_field_class_destroy(sc->event_common_context_fc);
1401 bt_object_put_ref(sc->default_clock_class);
1402 g_free(sc);
1403 }
1404
1405 static inline
1406 void ctf_stream_class_append_event_class(struct ctf_stream_class *sc,
1407 struct ctf_event_class *ec)
1408 {
1409 g_ptr_array_add(sc->event_classes, ec);
1410 g_hash_table_insert(sc->event_classes_by_id,
1411 GUINT_TO_POINTER((guint) ec->id), ec);
1412 }
1413
1414 static inline
1415 struct ctf_event_class *ctf_stream_class_borrow_event_class_by_id(
1416 struct ctf_stream_class *sc, uint64_t type)
1417 {
1418 BT_ASSERT(sc);
1419 return g_hash_table_lookup(sc->event_classes_by_id,
1420 GUINT_TO_POINTER((guint) type));
1421 }
1422
1423 static inline
1424 void _ctf_trace_class_env_entry_init(struct ctf_trace_class_env_entry *entry)
1425 {
1426 BT_ASSERT(entry);
1427 entry->name = g_string_new(NULL);
1428 BT_ASSERT(entry->name);
1429 entry->value.str = g_string_new(NULL);
1430 BT_ASSERT(entry->value.str);
1431 }
1432
1433 static inline
1434 void _ctf_trace_class_env_entry_fini(struct ctf_trace_class_env_entry *entry)
1435 {
1436 BT_ASSERT(entry);
1437
1438 if (entry->name) {
1439 g_string_free(entry->name, TRUE);
1440 }
1441
1442 if (entry->value.str) {
1443 g_string_free(entry->value.str, TRUE);
1444 }
1445 }
1446
1447 static inline
1448 struct ctf_trace_class *ctf_trace_class_create(void)
1449 {
1450 struct ctf_trace_class *tc = g_new0(struct ctf_trace_class, 1);
1451
1452 BT_ASSERT(tc);
1453 tc->name = g_string_new(NULL);
1454 tc->default_byte_order = -1;
1455 BT_ASSERT(tc->name);
1456 tc->clock_classes = g_ptr_array_new_with_free_func(
1457 (GDestroyNotify) bt_object_put_ref);
1458 BT_ASSERT(tc->clock_classes);
1459 tc->stream_classes = g_ptr_array_new_with_free_func(
1460 (GDestroyNotify) ctf_stream_class_destroy);
1461 BT_ASSERT(tc->stream_classes);
1462 tc->env_entries = g_array_new(FALSE, TRUE,
1463 sizeof(struct ctf_trace_class_env_entry));
1464 return tc;
1465 }
1466
1467 static inline
1468 void ctf_trace_class_destroy(struct ctf_trace_class *tc)
1469 {
1470 if (!tc) {
1471 return;
1472 }
1473
1474 if (tc->name) {
1475 g_string_free(tc->name, TRUE);
1476 }
1477
1478 ctf_field_class_destroy(tc->packet_header_fc);
1479
1480 if (tc->clock_classes) {
1481 g_ptr_array_free(tc->clock_classes, TRUE);
1482 }
1483
1484 if (tc->stream_classes) {
1485 g_ptr_array_free(tc->stream_classes, TRUE);
1486 }
1487
1488 if (tc->env_entries) {
1489 uint64_t i;
1490
1491 for (i = 0; i < tc->env_entries->len; i++) {
1492 struct ctf_trace_class_env_entry *entry =
1493 &g_array_index(tc->env_entries,
1494 struct ctf_trace_class_env_entry, i);
1495
1496 _ctf_trace_class_env_entry_fini(entry);
1497 }
1498
1499 g_array_free(tc->env_entries, TRUE);
1500 }
1501
1502 g_free(tc);
1503 }
1504
1505 static inline
1506 void ctf_trace_class_append_env_entry(struct ctf_trace_class *tc,
1507 const char *name, enum ctf_trace_class_env_entry_type type,
1508 const char *str_value, int64_t i_value)
1509 {
1510 struct ctf_trace_class_env_entry *entry;
1511
1512 BT_ASSERT(tc);
1513 BT_ASSERT(name);
1514 g_array_set_size(tc->env_entries, tc->env_entries->len + 1);
1515
1516 entry = &g_array_index(tc->env_entries,
1517 struct ctf_trace_class_env_entry, tc->env_entries->len - 1);
1518 entry->type = type;
1519 _ctf_trace_class_env_entry_init(entry);
1520 g_string_assign(entry->name, name);
1521
1522 if (str_value) {
1523 g_string_assign(entry->value.str, str_value);
1524 }
1525
1526 entry->value.i = i_value;
1527 }
1528
1529 static inline
1530 struct ctf_stream_class *ctf_trace_class_borrow_stream_class_by_id(
1531 struct ctf_trace_class *tc, uint64_t id)
1532 {
1533 uint64_t i;
1534 struct ctf_stream_class *ret_sc = NULL;
1535
1536 BT_ASSERT(tc);
1537
1538 for (i = 0; i < tc->stream_classes->len; i++) {
1539 struct ctf_stream_class *sc = tc->stream_classes->pdata[i];
1540
1541 if (sc->id == id) {
1542 ret_sc = sc;
1543 goto end;
1544 }
1545 }
1546
1547 end:
1548 return ret_sc;
1549 }
1550
1551 static inline
1552 struct bt_clock_class *ctf_trace_class_borrow_clock_class_by_name(
1553 struct ctf_trace_class *tc, const char *name)
1554 {
1555 uint64_t i;
1556 struct bt_clock_class *ret_cc = NULL;
1557
1558 BT_ASSERT(tc);
1559 BT_ASSERT(name);
1560
1561 for (i = 0; i < tc->clock_classes->len; i++) {
1562 struct bt_clock_class *cc = tc->clock_classes->pdata[i];
1563 const char *cc_name = bt_clock_class_get_name(cc);
1564
1565 BT_ASSERT(cc_name);
1566 if (strcmp(cc_name, name) == 0) {
1567 ret_cc = cc;
1568 goto end;
1569 }
1570 }
1571
1572 end:
1573 return ret_cc;
1574 }
1575
1576 static inline
1577 struct ctf_trace_class_env_entry *ctf_trace_class_borrow_env_entry_by_index(
1578 struct ctf_trace_class *tc, uint64_t index)
1579 {
1580 BT_ASSERT(tc);
1581 BT_ASSERT(index < tc->env_entries->len);
1582 return &g_array_index(tc->env_entries, struct ctf_trace_class_env_entry,
1583 index);
1584 }
1585
1586 static inline
1587 struct ctf_trace_class_env_entry *ctf_trace_class_borrow_env_entry_by_name(
1588 struct ctf_trace_class *tc, const char *name)
1589 {
1590 struct ctf_trace_class_env_entry *ret_entry = NULL;
1591 uint64_t i;
1592
1593 BT_ASSERT(tc);
1594 BT_ASSERT(name);
1595
1596 for (i = 0; i < tc->env_entries->len; i++) {
1597 struct ctf_trace_class_env_entry *env_entry =
1598 ctf_trace_class_borrow_env_entry_by_index(tc, i);
1599
1600 if (strcmp(env_entry->name->str, name) == 0) {
1601 ret_entry = env_entry;
1602 goto end;
1603 }
1604 }
1605
1606 end:
1607 return ret_entry;
1608 }
1609
1610 #endif /* _CTF_META_H */
BabelTrace - Trace Format Babel Tower
This page took 0.102738 seconds and 4 git commands to generate.