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