projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lib: have dedicated "dynamic array FC with/without length field" types
[babeltrace.git] / src / plugins / ctf / fs-sink / translate-trace-ir-to-ctf-ir.c
1 /*
2 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #define BT_COMP_LOG_SELF_COMP (ctx->self_comp)
24 #define BT_LOG_OUTPUT_LEVEL (ctx->log_level)
25 #define BT_LOG_TAG "PLUGIN/SINK.CTF.FS/TRANSLATE-TRACE-IR-TO-CTF-IR"
26 #include "logging/comp-logging.h"
27
28 #include <babeltrace2/babeltrace.h>
29 #include "common/macros.h"
30 #include "common/common.h"
31 #include "common/assert.h"
32 #include <stdio.h>
33 #include <stdbool.h>
34 #include <string.h>
35 #include <glib.h>
36
37 #include "fs-sink.h"
38 #include "fs-sink-ctf-meta.h"
39
40 struct field_path_elem {
41 uint64_t index_in_parent;
42 GString *name;
43
44 /* Weak */
45 const bt_field_class *ir_fc;
46
47 /* Weak */
48 struct fs_sink_ctf_field_class *parent_fc;
49 };
50
51 struct ctx {
52 bt_logging_level log_level;
53 bt_self_component *self_comp;
54
55 /* Weak */
56 struct fs_sink_ctf_stream_class *cur_sc;
57
58 /* Weak */
59 struct fs_sink_ctf_event_class *cur_ec;
60
61 bt_field_path_scope cur_scope;
62
63 /*
64 * Array of `struct field_path_elem` */
65 GArray *cur_path;
66 };
67
68 static inline
69 struct field_path_elem *cur_path_stack_at(struct ctx *ctx, uint64_t i)
70 {
71 BT_ASSERT(i < ctx->cur_path->len);
72 return &g_array_index(ctx->cur_path, struct field_path_elem, i);
73 }
74
75 static inline
76 struct field_path_elem *cur_path_stack_top(struct ctx *ctx)
77 {
78 BT_ASSERT(ctx->cur_path->len > 0);
79 return cur_path_stack_at(ctx, ctx->cur_path->len - 1);
80 }
81
82 static inline
83 bool is_reserved_member_name(const char *name, const char *reserved_name)
84 {
85 bool is_reserved = false;
86
87 if (strcmp(name, reserved_name) == 0) {
88 is_reserved = true;
89 goto end;
90 }
91
92 if (name[0] == '_' && strcmp(&name[1], reserved_name) == 0) {
93 is_reserved = true;
94 goto end;
95 }
96
97 end:
98 return is_reserved;
99 }
100
101 static const char *reserved_tsdl_keywords[] = {
102 "align",
103 "callsite",
104 "const",
105 "char",
106 "clock",
107 "double",
108 "enum",
109 "env",
110 "event",
111 "floating_point",
112 "float",
113 "integer",
114 "int",
115 "long",
116 "short",
117 "signed",
118 "stream",
119 "string",
120 "struct",
121 "trace",
122 "typealias",
123 "typedef",
124 "unsigned",
125 "variant",
126 "void",
127 "_Bool",
128 "_Complex",
129 "_Imaginary",
130 };
131
132 static inline
133 bool ist_valid_identifier(const char *name)
134 {
135 const char *at;
136 uint64_t i;
137 bool ist_valid = true;
138
139 /* Make sure the name is not a reserved keyword */
140 for (i = 0; i < sizeof(reserved_tsdl_keywords) / sizeof(*reserved_tsdl_keywords);
141 i++) {
142 if (strcmp(name, reserved_tsdl_keywords[i]) == 0) {
143 ist_valid = false;
144 goto end;
145 }
146 }
147
148 /* Make sure the name is not an empty string */
149 if (strlen(name) == 0) {
150 ist_valid = false;
151 goto end;
152 }
153
154 /* Make sure the name starts with a letter or `_` */
155 if (!isalpha(name[0]) && name[0] != '_') {
156 ist_valid = false;
157 goto end;
158 }
159
160 /* Make sure the name only contains letters, digits, and `_` */
161 for (at = name; *at != '\0'; at++) {
162 if (!isalnum(*at) && *at != '_') {
163 ist_valid = false;
164 goto end;
165 }
166 }
167
168 end:
169 return ist_valid;
170 }
171
172 static inline
173 bool must_protect_identifier(const char *name)
174 {
175 uint64_t i;
176 bool must_protect = false;
177
178 /* Protect a reserved keyword */
179 for (i = 0; i < sizeof(reserved_tsdl_keywords) / sizeof(*reserved_tsdl_keywords);
180 i++) {
181 if (strcmp(name, reserved_tsdl_keywords[i]) == 0) {
182 must_protect = true;
183 goto end;
184 }
185 }
186
187 /* Protect an identifier which already starts with `_` */
188 if (name[0] == '_') {
189 must_protect = true;
190 goto end;
191 }
192
193 end:
194 return must_protect;
195 }
196
197 static inline
198 int cur_path_stack_push(struct ctx *ctx,
199 uint64_t index_in_parent, const char *name,
200 bool force_protect_name, const bt_field_class *ir_fc,
201 struct fs_sink_ctf_field_class *parent_fc)
202 {
203 int ret = 0;
204 struct field_path_elem *field_path_elem;
205
206 g_array_set_size(ctx->cur_path, ctx->cur_path->len + 1);
207 field_path_elem = cur_path_stack_top(ctx);
208 field_path_elem->index_in_parent = index_in_parent;
209 field_path_elem->name = g_string_new(NULL);
210
211 if (name) {
212 if (force_protect_name) {
213 g_string_assign(field_path_elem->name, "_");
214 }
215
216 g_string_append(field_path_elem->name, name);
217
218 if (ctx->cur_scope == BT_FIELD_PATH_SCOPE_PACKET_CONTEXT) {
219 if (is_reserved_member_name(name, "packet_size") ||
220 is_reserved_member_name(name, "content_size") ||
221 is_reserved_member_name(name, "timestamp_begin") ||
222 is_reserved_member_name(name, "timestamp_end") ||
223 is_reserved_member_name(name, "events_discarded") ||
224 is_reserved_member_name(name, "packet_seq_num")) {
225 BT_COMP_LOGE("Unsupported reserved TSDL structure field class member "
226 "or variant field class option name: name=\"%s\"",
227 name);
228 ret = -1;
229 goto end;
230 }
231 }
232
233 if (!ist_valid_identifier(field_path_elem->name->str)) {
234 ret = -1;
235 BT_COMP_LOGE("Unsupported non-TSDL structure field class member "
236 "or variant field class option name: name=\"%s\"",
237 field_path_elem->name->str);
238 goto end;
239 }
240 }
241
242 field_path_elem->ir_fc = ir_fc;
243 field_path_elem->parent_fc = parent_fc;
244
245 end:
246 return ret;
247 }
248
249 static inline
250 void cur_path_stack_pop(struct ctx *ctx)
251 {
252 struct field_path_elem *field_path_elem;
253
254 BT_ASSERT(ctx->cur_path->len > 0);
255 field_path_elem = cur_path_stack_top(ctx);
256
257 if (field_path_elem->name) {
258 g_string_free(field_path_elem->name, TRUE);
259 field_path_elem->name = NULL;
260 }
261
262 g_array_set_size(ctx->cur_path, ctx->cur_path->len - 1);
263 }
264
265 /*
266 * Creates a relative field ref (a single name) from IR field path
267 * `tgt_ir_field_path`.
268 *
269 * This function tries to locate the target field class recursively from
270 * the top to the bottom of the context's current path using only the
271 * target field class's own name. This is because many CTF reading tools
272 * do not support a relative field ref with more than one element, for
273 * example `prev_struct.len`.
274 *
275 * Returns a negative value if this resolving operation failed.
276 */
277 static
278 int create_relative_field_ref(struct ctx *ctx,
279 const bt_field_path *tgt_ir_field_path, GString *tgt_field_ref,
280 struct fs_sink_ctf_field_class **user_tgt_fc)
281 {
282 int ret = 0;
283 struct fs_sink_ctf_field_class *tgt_fc = NULL;
284 uint64_t i;
285 int64_t si;
286 const char *tgt_fc_name = NULL;
287 struct field_path_elem *field_path_elem;
288
289 /* Get target field class's name */
290 switch (bt_field_path_get_root_scope(tgt_ir_field_path)) {
291 case BT_FIELD_PATH_SCOPE_PACKET_CONTEXT:
292 BT_ASSERT(ctx->cur_sc);
293 tgt_fc = ctx->cur_sc->packet_context_fc;
294 break;
295 case BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT:
296 BT_ASSERT(ctx->cur_sc);
297 tgt_fc = ctx->cur_sc->event_common_context_fc;
298 break;
299 case BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT:
300 BT_ASSERT(ctx->cur_ec);
301 tgt_fc = ctx->cur_ec->spec_context_fc;
302 break;
303 case BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD:
304 BT_ASSERT(ctx->cur_ec);
305 tgt_fc = ctx->cur_ec->payload_fc;
306 break;
307 default:
308 abort();
309 }
310
311 i = 0;
312
313 while (i < bt_field_path_get_item_count(tgt_ir_field_path)) {
314 const bt_field_path_item *fp_item =
315 bt_field_path_borrow_item_by_index_const(
316 tgt_ir_field_path, i);
317 struct fs_sink_ctf_named_field_class *named_fc = NULL;
318
319 BT_ASSERT(tgt_fc);
320 BT_ASSERT(fp_item);
321
322 if (bt_field_path_item_get_type(fp_item) ==
323 BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT) {
324 /* Not supported by CTF 1.8 */
325 ret = -1;
326 goto end;
327 }
328
329 switch (tgt_fc->type) {
330 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
331 BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
332 BT_FIELD_PATH_ITEM_TYPE_INDEX);
333 named_fc = fs_sink_ctf_field_class_struct_borrow_member_by_index(
334 (void *) tgt_fc,
335 bt_field_path_item_index_get_index(fp_item));
336 break;
337 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
338 BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
339 BT_FIELD_PATH_ITEM_TYPE_INDEX);
340 named_fc = fs_sink_ctf_field_class_variant_borrow_option_by_index(
341 (void *) tgt_fc,
342 bt_field_path_item_index_get_index(fp_item));
343 break;
344 case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY:
345 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
346 {
347 struct fs_sink_ctf_field_class_array_base *array_base_fc =
348 (void *) tgt_fc;
349
350 BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
351 BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT);
352 tgt_fc = array_base_fc->elem_fc;
353 break;
354 }
355 default:
356 abort();
357 }
358
359 if (named_fc) {
360 tgt_fc = named_fc->fc;
361 tgt_fc_name = named_fc->name->str;
362 i++;
363 }
364 }
365
366 BT_ASSERT(tgt_fc);
367 BT_ASSERT(tgt_fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_INT);
368 BT_ASSERT(tgt_fc_name);
369
370 /* Find target field class having this name in current context */
371 for (si = ctx->cur_path->len - 1; si >= 0; si--) {
372 struct fs_sink_ctf_field_class *fc;
373 struct fs_sink_ctf_field_class_struct *struct_fc = NULL;
374 struct fs_sink_ctf_field_class_variant *var_fc = NULL;
375 struct fs_sink_ctf_named_field_class *named_fc;
376 uint64_t len;
377
378 field_path_elem = cur_path_stack_at(ctx, (uint64_t) si);
379 fc = field_path_elem->parent_fc;
380 if (!fc) {
381 /* Reached stack's bottom */
382 ret = -1;
383 goto end;
384 }
385
386 switch (fc->type) {
387 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
388 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
389 break;
390 case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY:
391 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
392 continue;
393 default:
394 /* Not supported by TSDL 1.8 */
395 ret = -1;
396 goto end;
397 }
398
399 if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT) {
400 struct_fc = (void *) fc;
401 len = struct_fc->members->len;
402 } else {
403 var_fc = (void *) fc;
404 len = var_fc->options->len;
405 }
406
407 for (i = 0; i < len; i++) {
408 if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT) {
409 named_fc = fs_sink_ctf_field_class_struct_borrow_member_by_index(
410 struct_fc, i);
411 } else {
412 named_fc = fs_sink_ctf_field_class_variant_borrow_option_by_index(
413 var_fc, i);
414 }
415
416 if (strcmp(named_fc->name->str, tgt_fc_name) == 0) {
417 if (named_fc->fc == tgt_fc) {
418 g_string_assign(tgt_field_ref,
419 tgt_fc_name);
420
421 if (user_tgt_fc) {
422 *user_tgt_fc = tgt_fc;
423 }
424 } else {
425 /*
426 * Using only the target field
427 * class's name, we're not
428 * reaching the target field
429 * class. This is not supported
430 * by TSDL 1.8.
431 */
432 ret = -1;
433 }
434
435 goto end;
436 }
437 }
438 }
439
440 end:
441 return ret;
442 }
443
444 /*
445 * Creates an absolute field ref from IR field path `tgt_ir_field_path`.
446 *
447 * Returns a negative value if this resolving operation failed.
448 */
449 static
450 int create_absolute_field_ref(struct ctx *ctx,
451 const bt_field_path *tgt_ir_field_path, GString *tgt_field_ref,
452 struct fs_sink_ctf_field_class **user_tgt_fc)
453 {
454 int ret = 0;
455 struct fs_sink_ctf_field_class *fc = NULL;
456 uint64_t i;
457
458 switch (bt_field_path_get_root_scope(tgt_ir_field_path)) {
459 case BT_FIELD_PATH_SCOPE_PACKET_CONTEXT:
460 BT_ASSERT(ctx->cur_sc);
461 fc = ctx->cur_sc->packet_context_fc;
462 g_string_assign(tgt_field_ref, "stream.packet.context");
463 break;
464 case BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT:
465 BT_ASSERT(ctx->cur_sc);
466 fc = ctx->cur_sc->event_common_context_fc;
467 g_string_assign(tgt_field_ref, "stream.event.context");
468 break;
469 case BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT:
470 BT_ASSERT(ctx->cur_ec);
471 fc = ctx->cur_ec->spec_context_fc;
472 g_string_assign(tgt_field_ref, "event.context");
473 break;
474 case BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD:
475 BT_ASSERT(ctx->cur_ec);
476 fc = ctx->cur_ec->payload_fc;
477 g_string_assign(tgt_field_ref, "event.fields");
478 break;
479 default:
480 abort();
481 }
482
483 BT_ASSERT(fc);
484
485 for (i = 0; i < bt_field_path_get_item_count(tgt_ir_field_path); i++) {
486 const bt_field_path_item *fp_item =
487 bt_field_path_borrow_item_by_index_const(
488 tgt_ir_field_path, i);
489 struct fs_sink_ctf_named_field_class *named_fc = NULL;
490
491 if (bt_field_path_item_get_type(fp_item) !=
492 BT_FIELD_PATH_ITEM_TYPE_INDEX) {
493 /* Not supported by TSDL 1.8 */
494 ret = -1;
495 goto end;
496 }
497
498 switch (fc->type) {
499 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
500 BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
501 BT_FIELD_PATH_ITEM_TYPE_INDEX);
502 named_fc = fs_sink_ctf_field_class_struct_borrow_member_by_index(
503 (void *) fc,
504 bt_field_path_item_index_get_index(fp_item));
505 break;
506 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
507 BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
508 BT_FIELD_PATH_ITEM_TYPE_INDEX);
509 named_fc = fs_sink_ctf_field_class_variant_borrow_option_by_index(
510 (void *) fc,
511 bt_field_path_item_index_get_index(fp_item));
512 break;
513 default:
514 abort();
515 }
516
517 BT_ASSERT(named_fc);
518 g_string_append_c(tgt_field_ref, '.');
519 g_string_append(tgt_field_ref, named_fc->name->str);
520 fc = named_fc->fc;
521 }
522
523 if (user_tgt_fc) {
524 *user_tgt_fc = fc;
525 }
526
527 end:
528 return ret;
529 }
530
531 /*
532 * Resolves a target field class located at `tgt_ir_field_path`, writing
533 * the resolved field ref to `tgt_field_ref` and setting
534 * `*create_before` according to whether or not the target field must be
535 * created immediately before (in which case `tgt_field_ref` is
536 * irrelevant).
537 */
538 static
539 void resolve_field_class(struct ctx *ctx,
540 const bt_field_path *tgt_ir_field_path,
541 GString *tgt_field_ref, bool *create_before,
542 struct fs_sink_ctf_field_class **user_tgt_fc)
543 {
544 int ret;
545 bt_field_path_scope tgt_scope;
546
547 *create_before = false;
548
549 if (!tgt_ir_field_path) {
550 *create_before = true;
551 goto end;
552 }
553
554 tgt_scope = bt_field_path_get_root_scope(tgt_ir_field_path);
555
556 if (tgt_scope == ctx->cur_scope) {
557 /*
558 * Try, in this order:
559 *
560 * 1. Use a relative path, using only the target field
561 * class's name. This is what is the most commonly
562 * supported by popular CTF reading tools.
563 *
564 * 2. Use an absolute path. This could fail if there's
565 * an array field class from the current root's field
566 * class to the target field class.
567 *
568 * 3. Create the target field class before the
569 * requesting field class (fallback).
570 */
571 ret = create_relative_field_ref(ctx, tgt_ir_field_path,
572 tgt_field_ref, user_tgt_fc);
573 if (ret) {
574 ret = create_absolute_field_ref(ctx, tgt_ir_field_path,
575 tgt_field_ref, user_tgt_fc);
576 if (ret) {
577 *create_before = true;
578 ret = 0;
579 goto end;
580 }
581 }
582 } else {
583 ret = create_absolute_field_ref(ctx, tgt_ir_field_path,
584 tgt_field_ref, user_tgt_fc);
585
586 /* It must always work in previous scopes */
587 BT_ASSERT(ret == 0);
588 }
589
590 end:
591 return;
592 }
593
594 static
595 int translate_field_class(struct ctx *ctx);
596
597 static inline
598 void append_to_parent_field_class(struct ctx *ctx,
599 struct fs_sink_ctf_field_class *fc)
600 {
601 struct fs_sink_ctf_field_class *parent_fc =
602 cur_path_stack_top(ctx)->parent_fc;
603
604 switch (parent_fc->type) {
605 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
606 fs_sink_ctf_field_class_struct_append_member((void *) parent_fc,
607 cur_path_stack_top(ctx)->name->str, fc);
608 break;
609 case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION:
610 {
611 struct fs_sink_ctf_field_class_option *opt_fc =
612 (void *) parent_fc;
613
614 BT_ASSERT(!opt_fc->content_fc);
615 opt_fc->content_fc = fc;
616 opt_fc->base.alignment = fc->alignment;
617 break;
618 }
619 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
620 fs_sink_ctf_field_class_variant_append_option((void *) parent_fc,
621 cur_path_stack_top(ctx)->name->str, fc);
622 break;
623 case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY:
624 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
625 {
626 struct fs_sink_ctf_field_class_array_base *array_base_fc =
627 (void *) parent_fc;
628
629 BT_ASSERT(!array_base_fc->elem_fc);
630 array_base_fc->elem_fc = fc;
631 array_base_fc->base.alignment = fc->alignment;
632 break;
633 }
634 default:
635 abort();
636 }
637 }
638
639 static inline
640 void update_parent_field_class_alignment(struct ctx *ctx,
641 unsigned int alignment)
642 {
643 struct fs_sink_ctf_field_class *parent_fc =
644 cur_path_stack_top(ctx)->parent_fc;
645
646 switch (parent_fc->type) {
647 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
648 fs_sink_ctf_field_class_struct_align_at_least(
649 (void *) parent_fc, alignment);
650 break;
651 case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY:
652 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
653 {
654 struct fs_sink_ctf_field_class_array_base *array_base_fc =
655 (void *) parent_fc;
656
657 array_base_fc->base.alignment = alignment;
658 break;
659 }
660 default:
661 break;
662 }
663 }
664
665 static inline
666 int translate_structure_field_class_members(struct ctx *ctx,
667 struct fs_sink_ctf_field_class_struct *struct_fc,
668 const bt_field_class *ir_fc)
669 {
670 int ret = 0;
671 uint64_t i;
672
673 for (i = 0; i < bt_field_class_structure_get_member_count(ir_fc); i++) {
674 const bt_field_class_structure_member *member;
675 const char *name;
676 const bt_field_class *memb_ir_fc;
677
678 member =
679 bt_field_class_structure_borrow_member_by_index_const(
680 ir_fc, i);
681 name = bt_field_class_structure_member_get_name(member);
682 memb_ir_fc = bt_field_class_structure_member_borrow_field_class_const(
683 member);
684 ret = cur_path_stack_push(ctx, i, name, true, memb_ir_fc,
685 (void *) struct_fc);
686 if (ret) {
687 BT_COMP_LOGE("Cannot translate structure field class member: "
688 "name=\"%s\"", name);
689 goto end;
690 }
691
692 ret = translate_field_class(ctx);
693 if (ret) {
694 BT_COMP_LOGE("Cannot translate structure field class member: "
695 "name=\"%s\"", name);
696 goto end;
697 }
698
699 cur_path_stack_pop(ctx);
700 }
701
702 end:
703 return ret;
704 }
705
706 static inline
707 int translate_structure_field_class(struct ctx *ctx)
708 {
709 int ret;
710 struct fs_sink_ctf_field_class_struct *fc =
711 fs_sink_ctf_field_class_struct_create_empty(
712 cur_path_stack_top(ctx)->ir_fc,
713 cur_path_stack_top(ctx)->index_in_parent);
714
715 BT_ASSERT(fc);
716 append_to_parent_field_class(ctx, (void *) fc);
717 ret = translate_structure_field_class_members(ctx, fc, fc->base.ir_fc);
718 if (ret) {
719 goto end;
720 }
721
722 update_parent_field_class_alignment(ctx, fc->base.alignment);
723
724 end:
725 return ret;
726 }
727
728 /*
729 * This function protects a given variant FC option name (with the `_`
730 * prefix) if required. On success, `name_buf->str` contains the variant
731 * FC option name to use (original option name or protected if
732 * required).
733 *
734 * One of the goals of `sink.ctf.fs` is to write a CTF trace which is as
735 * close as possible to an original CTF trace as decoded by
736 * `src.ctf.fs`.
737 *
738 * This scenario is valid in CTF 1.8:
739 *
740 * enum {
741 * HELLO,
742 * MEOW
743 * } tag;
744 *
745 * variant <tag> {
746 * int HELLO;
747 * string MEOW;
748 * };
749 *
750 * Once in trace IR, the enumeration FC mapping names and variant FC
751 * option names are kept as is. For this reason, we don't want to
752 * protect the variant FC option names here (by prepending `_`): this
753 * would make the variant FC option name and the enumeration FC mapping
754 * name not match.
755 *
756 * This scenario is also valid in CTF 1.8:
757 *
758 * enum {
759 * _HELLO,
760 * MEOW
761 * } tag;
762 *
763 * variant <tag> {
764 * int _HELLO;
765 * string MEOW;
766 * };
767 *
768 * Once in trace IR, the enumeration FC mapping names are kept as is,
769 * but the `_HELLO` variant FC option name becomes `HELLO` (unprotected
770 * for presentation, as recommended by CTF 1.8). When going back to
771 * TSDL, we need to protect `HELLO` so that it becomes `_HELLO` to match
772 * the corresponding enumeration FC mapping name.
773 *
774 * This scenario is also valid in CTF 1.8:
775 *
776 * enum {
777 * __HELLO,
778 * MEOW
779 * } tag;
780 *
781 * variant <tag> {
782 * int __HELLO;
783 * string MEOW;
784 * };
785 *
786 * Once in trace IR, the enumeration FC mapping names are kept as is,
787 * but the `__HELLO` variant FC option name becomes `_HELLO`
788 * (unprotected). When going back to TSDL, we need to protect `_HELLO`
789 * so that it becomes `__HELLO` to match the corresponding enumeration
790 * FC mapping name.
791 *
792 * `src.ctf.fs` always uses the _same_ integer range sets for a selector
793 * FC mapping and a corresponding variant FC option. We can use that
794 * fact to find the original variant FC option names by matching variant
795 * FC options and enumeration FC mappings by range set.
796 */
797 static
798 int maybe_protect_variant_option_name(const bt_field_class *ir_var_fc,
799 const bt_field_class *ir_tag_fc, uint64_t opt_i,
800 GString *name_buf)
801 {
802 int ret = 0;
803 uint64_t i;
804 bt_field_class_type ir_var_fc_type;
805 const void *opt_ranges = NULL;
806 const char *mapping_label = NULL;
807 const char *ir_opt_name;
808 const bt_field_class_variant_option *base_var_opt;
809 bool force_protect = false;
810
811 ir_var_fc_type = bt_field_class_get_type(ir_var_fc);
812 base_var_opt = bt_field_class_variant_borrow_option_by_index_const(
813 ir_var_fc, opt_i);
814 BT_ASSERT(base_var_opt);
815 ir_opt_name = bt_field_class_variant_option_get_name(base_var_opt);
816 BT_ASSERT(ir_opt_name);
817
818 /*
819 * Check if the variant FC option name is required to be
820 * protected (reserved TSDL keyword or starts with `_`). In that
821 * case, the name of the selector FC mapping we find must match
822 * exactly the protected name.
823 */
824 force_protect = must_protect_identifier(ir_opt_name);
825 if (force_protect) {
826 g_string_assign(name_buf, "_");
827 g_string_append(name_buf, ir_opt_name);
828 } else {
829 g_string_assign(name_buf, ir_opt_name);
830 }
831
832 /* Borrow option's ranges */
833 if (ir_var_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR) {
834 /* No ranges: we're done */
835 goto end;
836 } if (ir_var_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR) {
837 const bt_field_class_variant_with_selector_integer_unsigned_option *var_opt =
838 bt_field_class_variant_with_selector_integer_unsigned_borrow_option_by_index_const(
839 ir_var_fc, opt_i);
840 opt_ranges =
841 bt_field_class_variant_with_selector_integer_unsigned_option_borrow_ranges_const(
842 var_opt);
843 } else {
844 const bt_field_class_variant_with_selector_integer_signed_option *var_opt =
845 bt_field_class_variant_with_selector_integer_signed_borrow_option_by_index_const(
846 ir_var_fc, opt_i);
847 opt_ranges =
848 bt_field_class_variant_with_selector_integer_signed_option_borrow_ranges_const(
849 var_opt);
850 }
851
852 /* Find corresponding mapping by range set in selector FC */
853 for (i = 0; i < bt_field_class_enumeration_get_mapping_count(ir_tag_fc);
854 i++) {
855 if (ir_var_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR) {
856 const bt_field_class_enumeration_mapping *mapping_base;
857 const bt_field_class_enumeration_unsigned_mapping *mapping;
858 const bt_integer_range_set_unsigned *mapping_ranges;
859
860 mapping = bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(
861 ir_tag_fc, i);
862 mapping_ranges = bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(
863 mapping);
864
865 if (bt_integer_range_set_unsigned_is_equal(opt_ranges,
866 mapping_ranges)) {
867 /* We have a winner */
868 mapping_base =
869 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(
870 mapping);
871 mapping_label =
872 bt_field_class_enumeration_mapping_get_label(
873 mapping_base);
874 break;
875 }
876 } else {
877 const bt_field_class_enumeration_mapping *mapping_base;
878 const bt_field_class_enumeration_signed_mapping *mapping;
879 const bt_integer_range_set_signed *mapping_ranges;
880
881 mapping = bt_field_class_enumeration_signed_borrow_mapping_by_index_const(
882 ir_tag_fc, i);
883 mapping_ranges = bt_field_class_enumeration_signed_mapping_borrow_ranges_const(
884 mapping);
885
886 if (bt_integer_range_set_signed_is_equal(opt_ranges,
887 mapping_ranges)) {
888 /* We have a winner */
889 mapping_base =
890 bt_field_class_enumeration_signed_mapping_as_mapping_const(
891 mapping);
892 mapping_label =
893 bt_field_class_enumeration_mapping_get_label(
894 mapping_base);
895 break;
896 }
897 }
898 }
899
900 if (!mapping_label) {
901 /* Range set not found: invalid selector for CTF 1.8 */
902 ret = -1;
903 goto end;
904 }
905
906 /*
907 * If the enumeration FC mapping name is not the same as the
908 * variant FC option name and we didn't protect already, try
909 * protecting the option name and check again.
910 */
911 if (strcmp(mapping_label, name_buf->str) != 0) {
912 if (force_protect) {
913 ret = -1;
914 goto end;
915 }
916
917 if (mapping_label[0] == '\0') {
918 ret = -1;
919 goto end;
920 }
921
922 g_string_assign(name_buf, "_");
923 g_string_append(name_buf, ir_opt_name);
924
925 if (strcmp(mapping_label, name_buf->str) != 0) {
926 ret = -1;
927 goto end;
928 }
929 }
930
931 end:
932 return ret;
933 }
934
935 static inline
936 int translate_option_field_class(struct ctx *ctx)
937 {
938 struct fs_sink_ctf_field_class_option *fc =
939 fs_sink_ctf_field_class_option_create_empty(
940 cur_path_stack_top(ctx)->ir_fc,
941 cur_path_stack_top(ctx)->index_in_parent);
942 const bt_field_class *content_ir_fc =
943 bt_field_class_option_borrow_field_class_const(fc->base.ir_fc);
944 int ret;
945
946 BT_ASSERT(fc);
947
948 /*
949 * CTF 1.8 does not support the option field class type. To
950 * write something anyway, this component translates this type
951 * to a variant field class where the options are:
952 *
953 * * An empty structure field class.
954 * * The optional field class itself.
955 *
956 * The "tag" is always generated/before in that case (an 8-bit
957 * unsigned enumeration field class).
958 */
959 append_to_parent_field_class(ctx, (void *) fc);
960 ret = cur_path_stack_push(ctx, UINT64_C(-1), NULL, false, content_ir_fc,
961 (void *) fc);
962 if (ret) {
963 BT_COMP_LOGE_STR("Cannot translate option field class content.");
964 goto end;
965 }
966
967 ret = translate_field_class(ctx);
968 if (ret) {
969 BT_COMP_LOGE_STR("Cannot translate option field class content.");
970 goto end;
971 }
972
973 cur_path_stack_pop(ctx);
974 update_parent_field_class_alignment(ctx, fc->base.alignment);
975
976 end:
977 return ret;
978 }
979
980 static inline
981 int translate_variant_field_class(struct ctx *ctx)
982 {
983 int ret = 0;
984 uint64_t i;
985 struct fs_sink_ctf_field_class_variant *fc =
986 fs_sink_ctf_field_class_variant_create_empty(
987 cur_path_stack_top(ctx)->ir_fc,
988 cur_path_stack_top(ctx)->index_in_parent);
989 bt_field_class_type ir_fc_type;
990 const bt_field_path *ir_selector_field_path = NULL;
991 struct fs_sink_ctf_field_class *tgt_fc = NULL;
992 GString *name_buf = g_string_new(NULL);
993 bt_value *prot_opt_names = bt_value_array_create();
994 uint64_t opt_count;
995
996 BT_ASSERT(fc);
997 BT_ASSERT(name_buf);
998 BT_ASSERT(prot_opt_names);
999 ir_fc_type = bt_field_class_get_type(fc->base.ir_fc);
1000 opt_count = bt_field_class_variant_get_option_count(fc->base.ir_fc);
1001
1002 if (ir_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR ||
1003 ir_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR) {
1004 ir_selector_field_path = bt_field_class_variant_with_selector_borrow_selector_field_path_const(
1005 fc->base.ir_fc);
1006 BT_ASSERT(ir_selector_field_path);
1007 }
1008
1009 /* Resolve tag field class before appending to parent */
1010 resolve_field_class(ctx, ir_selector_field_path, fc->tag_ref,
1011 &fc->tag_is_before, &tgt_fc);
1012
1013 if (ir_selector_field_path && tgt_fc) {
1014 uint64_t mapping_count;
1015 uint64_t option_count;
1016
1017 /* CTF 1.8: selector FC must be an enumeration FC */
1018 bt_field_class_type type = bt_field_class_get_type(
1019 tgt_fc->ir_fc);
1020
1021 if (type != BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION &&
1022 type != BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
1023 fc->tag_is_before = true;
1024 goto validate_opts;
1025 }
1026
1027 /*
1028 * Call maybe_protect_variant_option_name() for each
1029 * option below. In that case we also want selector FC
1030 * to contain as many mappings as the variant FC has
1031 * options.
1032 */
1033 mapping_count = bt_field_class_enumeration_get_mapping_count(
1034 tgt_fc->ir_fc);
1035 option_count = bt_field_class_variant_get_option_count(
1036 fc->base.ir_fc);
1037
1038 if (mapping_count != option_count) {
1039 fc->tag_is_before = true;
1040 goto validate_opts;
1041 }
1042 } else {
1043 /*
1044 * No compatible selector field class for CTF 1.8:
1045 * create the appropriate selector field class.
1046 */
1047 fc->tag_is_before = true;
1048 goto validate_opts;
1049 }
1050
1051 validate_opts:
1052 /*
1053 * First pass: detect any option name clash with option name
1054 * protection. In that case, we don't fail: just create the
1055 * selector field class before the variant field class.
1056 *
1057 * After this, `prot_opt_names` contains the final option names,
1058 * potentially protected if needed. They can still be invalid
1059 * TSDL identifiers however; this will be checked by
1060 * cur_path_stack_push().
1061 */
1062 for (i = 0; i < opt_count; i++) {
1063 if (!fc->tag_is_before) {
1064 BT_ASSERT(tgt_fc->ir_fc);
1065 ret = maybe_protect_variant_option_name(fc->base.ir_fc,
1066 tgt_fc->ir_fc, i, name_buf);
1067 if (ret) {
1068 fc->tag_is_before = true;
1069 }
1070 }
1071
1072 ret = bt_value_array_append_string_element(prot_opt_names,
1073 name_buf->str);
1074 if (ret) {
1075 goto end;
1076 }
1077 }
1078
1079 for (i = 0; i < opt_count; i++) {
1080 uint64_t j;
1081 const bt_value *opt_name_a =
1082 bt_value_array_borrow_element_by_index_const(
1083 prot_opt_names, i);
1084
1085 for (j = 0; j < opt_count; j++) {
1086 const bt_value *opt_name_b;
1087
1088 if (i == j) {
1089 continue;
1090 }
1091
1092 opt_name_b =
1093 bt_value_array_borrow_element_by_index_const(
1094 prot_opt_names, j);
1095 if (bt_value_is_equal(opt_name_a, opt_name_b)) {
1096 /*
1097 * Variant FC option names are not
1098 * unique when protected.
1099 */
1100 fc->tag_is_before = true;
1101 goto append_to_parent;
1102 }
1103 }
1104 }
1105
1106 append_to_parent:
1107 append_to_parent_field_class(ctx, (void *) fc);
1108
1109 for (i = 0; i < opt_count; i++) {
1110 const bt_field_class_variant_option *opt;
1111 const bt_field_class *opt_ir_fc;
1112 const bt_value *prot_opt_name_val =
1113 bt_value_array_borrow_element_by_index_const(
1114 prot_opt_names, i);
1115 const char *prot_opt_name = bt_value_string_get(
1116 prot_opt_name_val);
1117
1118 BT_ASSERT(prot_opt_name);
1119 opt = bt_field_class_variant_borrow_option_by_index_const(
1120 fc->base.ir_fc, i);
1121 opt_ir_fc = bt_field_class_variant_option_borrow_field_class_const(
1122 opt);
1123
1124 /*
1125 * We don't ask cur_path_stack_push() to protect the
1126 * option name because it's already protected at this
1127 * point.
1128 */
1129 ret = cur_path_stack_push(ctx, i, prot_opt_name, false,
1130 opt_ir_fc, (void *) fc);
1131 if (ret) {
1132 BT_COMP_LOGE("Cannot translate variant field class option: "
1133 "name=\"%s\"", prot_opt_name);
1134 goto end;
1135 }
1136
1137 ret = translate_field_class(ctx);
1138 if (ret) {
1139 BT_COMP_LOGE("Cannot translate variant field class option: "
1140 "name=\"%s\"", prot_opt_name);
1141 goto end;
1142 }
1143
1144 cur_path_stack_pop(ctx);
1145 }
1146
1147 end:
1148 if (name_buf) {
1149 g_string_free(name_buf, TRUE);
1150 }
1151
1152 bt_value_put_ref(prot_opt_names);
1153 return ret;
1154 }
1155
1156 static inline
1157 int translate_static_array_field_class(struct ctx *ctx)
1158 {
1159 struct fs_sink_ctf_field_class_array *fc =
1160 fs_sink_ctf_field_class_array_create_empty(
1161 cur_path_stack_top(ctx)->ir_fc,
1162 cur_path_stack_top(ctx)->index_in_parent);
1163 const bt_field_class *elem_ir_fc =
1164 bt_field_class_array_borrow_element_field_class_const(
1165 fc->base.base.ir_fc);
1166 int ret;
1167
1168 BT_ASSERT(fc);
1169 append_to_parent_field_class(ctx, (void *) fc);
1170 ret = cur_path_stack_push(ctx, UINT64_C(-1), NULL, false, elem_ir_fc,
1171 (void *) fc);
1172 if (ret) {
1173 BT_COMP_LOGE_STR("Cannot translate static array field class element.");
1174 goto end;
1175 }
1176
1177 ret = translate_field_class(ctx);
1178 if (ret) {
1179 BT_COMP_LOGE_STR("Cannot translate static array field class element.");
1180 goto end;
1181 }
1182
1183 cur_path_stack_pop(ctx);
1184 update_parent_field_class_alignment(ctx, fc->base.base.alignment);
1185
1186 end:
1187 return ret;
1188 }
1189
1190 static inline
1191 int translate_dynamic_array_field_class(struct ctx *ctx)
1192 {
1193 struct fs_sink_ctf_field_class_sequence *fc =
1194 fs_sink_ctf_field_class_sequence_create_empty(
1195 cur_path_stack_top(ctx)->ir_fc,
1196 cur_path_stack_top(ctx)->index_in_parent);
1197 const bt_field_class *elem_ir_fc =
1198 bt_field_class_array_borrow_element_field_class_const(
1199 fc->base.base.ir_fc);
1200 int ret;
1201
1202 BT_ASSERT(fc);
1203
1204 /* Resolve length field class before appending to parent */
1205 if (bt_field_class_get_type(cur_path_stack_top(ctx)->ir_fc) ==
1206 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD) {
1207 resolve_field_class(ctx,
1208 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1209 fc->base.base.ir_fc),
1210 fc->length_ref, &fc->length_is_before, NULL);
1211 }
1212
1213 append_to_parent_field_class(ctx, (void *) fc);
1214 ret = cur_path_stack_push(ctx, UINT64_C(-1), NULL, false, elem_ir_fc,
1215 (void *) fc);
1216 if (ret) {
1217 BT_COMP_LOGE_STR("Cannot translate dynamic array field class element.");
1218 goto end;
1219 }
1220
1221 ret = translate_field_class(ctx);
1222 if (ret) {
1223 BT_COMP_LOGE_STR("Cannot translate dynamic array field class element.");
1224 goto end;
1225 }
1226
1227 cur_path_stack_pop(ctx);
1228 update_parent_field_class_alignment(ctx, fc->base.base.alignment);
1229
1230 end:
1231 return ret;
1232 }
1233
1234 static inline
1235 int translate_bool_field_class(struct ctx *ctx)
1236 {
1237 struct fs_sink_ctf_field_class_bool *fc =
1238 fs_sink_ctf_field_class_bool_create(
1239 cur_path_stack_top(ctx)->ir_fc,
1240 cur_path_stack_top(ctx)->index_in_parent);
1241
1242 BT_ASSERT(fc);
1243 append_to_parent_field_class(ctx, (void *) fc);
1244 return 0;
1245 }
1246
1247 static inline
1248 int translate_bit_array_field_class(struct ctx *ctx)
1249 {
1250 struct fs_sink_ctf_field_class_bit_array *fc =
1251 fs_sink_ctf_field_class_bit_array_create(
1252 cur_path_stack_top(ctx)->ir_fc,
1253 cur_path_stack_top(ctx)->index_in_parent);
1254
1255 BT_ASSERT(fc);
1256 append_to_parent_field_class(ctx, (void *) fc);
1257 return 0;
1258 }
1259
1260 static inline
1261 int translate_integer_field_class(struct ctx *ctx)
1262 {
1263 struct fs_sink_ctf_field_class_int *fc =
1264 fs_sink_ctf_field_class_int_create(
1265 cur_path_stack_top(ctx)->ir_fc,
1266 cur_path_stack_top(ctx)->index_in_parent);
1267
1268 BT_ASSERT(fc);
1269 append_to_parent_field_class(ctx, (void *) fc);
1270 return 0;
1271 }
1272
1273 static inline
1274 int translate_real_field_class(struct ctx *ctx)
1275 {
1276 struct fs_sink_ctf_field_class_float *fc =
1277 fs_sink_ctf_field_class_float_create(
1278 cur_path_stack_top(ctx)->ir_fc,
1279 cur_path_stack_top(ctx)->index_in_parent);
1280
1281 BT_ASSERT(fc);
1282 append_to_parent_field_class(ctx, (void *) fc);
1283 return 0;
1284 }
1285
1286 static inline
1287 int translate_string_field_class(struct ctx *ctx)
1288 {
1289 struct fs_sink_ctf_field_class_string *fc =
1290 fs_sink_ctf_field_class_string_create(
1291 cur_path_stack_top(ctx)->ir_fc,
1292 cur_path_stack_top(ctx)->index_in_parent);
1293
1294 BT_ASSERT(fc);
1295 append_to_parent_field_class(ctx, (void *) fc);
1296 return 0;
1297 }
1298
1299 /*
1300 * Translates a field class, recursively.
1301 *
1302 * The field class's IR field class, parent field class, and index
1303 * within its parent are in the context's current path's top element
1304 * (cur_path_stack_top()).
1305 */
1306 static
1307 int translate_field_class(struct ctx *ctx)
1308 {
1309 int ret;
1310
1311 switch (bt_field_class_get_type(cur_path_stack_top(ctx)->ir_fc)) {
1312 case BT_FIELD_CLASS_TYPE_BOOL:
1313 ret = translate_bool_field_class(ctx);
1314 break;
1315 case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
1316 ret = translate_bit_array_field_class(ctx);
1317 break;
1318 case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
1319 case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
1320 case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
1321 case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
1322 ret = translate_integer_field_class(ctx);
1323 break;
1324 case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
1325 case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
1326 ret = translate_real_field_class(ctx);
1327 break;
1328 case BT_FIELD_CLASS_TYPE_STRING:
1329 ret = translate_string_field_class(ctx);
1330 break;
1331 case BT_FIELD_CLASS_TYPE_STRUCTURE:
1332 ret = translate_structure_field_class(ctx);
1333 break;
1334 case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
1335 ret = translate_static_array_field_class(ctx);
1336 break;
1337 case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
1338 case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
1339 ret = translate_dynamic_array_field_class(ctx);
1340 break;
1341 case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR:
1342 case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR:
1343 case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR:
1344 case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR:
1345 ret = translate_option_field_class(ctx);
1346 break;
1347 case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR:
1348 case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR:
1349 case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR:
1350 ret = translate_variant_field_class(ctx);
1351 break;
1352 default:
1353 abort();
1354 }
1355
1356 return ret;
1357 }
1358
1359 static
1360 int set_field_ref(struct fs_sink_ctf_field_class *fc, const char *fc_name,
1361 struct fs_sink_ctf_field_class *parent_fc)
1362 {
1363 int ret = 0;
1364 GString *field_ref = NULL;
1365 bool is_before;
1366 const char *tgt_type;
1367 struct fs_sink_ctf_field_class_struct *parent_struct_fc =
1368 (void *) parent_fc;
1369 uint64_t i;
1370 unsigned int suffix = 0;
1371
1372 if (!fc_name || !parent_fc ||
1373 parent_fc->type != FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT) {
1374 /* Not supported */
1375 ret = -1;
1376 goto end;
1377 }
1378
1379 switch (fc->type) {
1380 case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION:
1381 {
1382 /*
1383 * CTF 1.8 does not support the option field class type.
1384 * To write something anyway, this component translates
1385 * this type to a variant field class where the options
1386 * are:
1387 *
1388 * * An empty structure field class.
1389 * * The optional field class itself.
1390 *
1391 * Because the option field class becomes a CTF variant
1392 * field class, we use the term "tag" too here.
1393 *
1394 * The "tag" is always generated/before in that case (an
1395 * 8-bit unsigned enumeration field class).
1396 */
1397 struct fs_sink_ctf_field_class_option *opt_fc = (void *) fc;
1398
1399 field_ref = opt_fc->tag_ref;
1400 is_before = true;
1401 tgt_type = "tag";
1402 break;
1403 }
1404 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
1405 {
1406 struct fs_sink_ctf_field_class_sequence *seq_fc = (void *) fc;
1407
1408 field_ref = seq_fc->length_ref;
1409 is_before = seq_fc->length_is_before;
1410 tgt_type = "len";
1411 break;
1412 }
1413 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
1414 {
1415 struct fs_sink_ctf_field_class_variant *var_fc = (void *) fc;
1416
1417 field_ref = var_fc->tag_ref;
1418 is_before = var_fc->tag_is_before;
1419 tgt_type = "tag";
1420 break;
1421 }
1422 default:
1423 abort();
1424 }
1425
1426 BT_ASSERT(field_ref);
1427
1428 if (!is_before) {
1429 goto end;
1430 }
1431
1432 /* Initial field ref */
1433 g_string_printf(field_ref, "__%s_%s", fc_name, tgt_type);
1434
1435 /*
1436 * Make sure field ref does not clash with an existing field
1437 * class name within the same parent structure field class.
1438 */
1439 while (true) {
1440 bool name_ok = true;
1441
1442 for (i = 0; i < parent_struct_fc->members->len; i++) {
1443 struct fs_sink_ctf_named_field_class *named_fc =
1444 fs_sink_ctf_field_class_struct_borrow_member_by_index(
1445 parent_struct_fc, i);
1446
1447 if (strcmp(field_ref->str, named_fc->name->str) == 0) {
1448 /* Name clash */
1449 name_ok = false;
1450 break;
1451 }
1452 }
1453
1454 if (name_ok) {
1455 /* No clash: we're done */
1456 break;
1457 }
1458
1459 /* Append suffix and try again */
1460 g_string_printf(field_ref, "__%s_%s_%u", fc_name, tgt_type,
1461 suffix);
1462 suffix++;
1463 }
1464
1465 end:
1466 return ret;
1467 }
1468
1469 /*
1470 * This function recursively sets field refs of sequence and variant
1471 * field classes when they are immediately before, avoiding name clashes
1472 * with existing field class names.
1473 *
1474 * It can fail at this point if, for example, a sequence field class of
1475 * which to set the length's field ref has something else than a
1476 * structure field class as its parent: in this case, there's no
1477 * location to place the length field class immediately before the
1478 * sequence field class.
1479 */
1480 static
1481 int set_field_refs(struct fs_sink_ctf_field_class * const fc,
1482 const char *fc_name, struct fs_sink_ctf_field_class *parent_fc)
1483 {
1484 int ret = 0;
1485 enum fs_sink_ctf_field_class_type fc_type;
1486 BT_ASSERT(fc);
1487
1488 fc_type = fc->type;
1489
1490 switch (fc_type) {
1491 case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION:
1492 {
1493 struct fs_sink_ctf_field_class_option *opt_fc = (void *) fc;
1494
1495 ret = set_field_ref(fc, fc_name, parent_fc);
1496 if (ret) {
1497 goto end;
1498 }
1499
1500 ret = set_field_refs(opt_fc->content_fc, NULL, fc);
1501 if (ret) {
1502 goto end;
1503 }
1504
1505 break;
1506 }
1507 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
1508 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
1509 {
1510 uint64_t i;
1511 uint64_t len;
1512 struct fs_sink_ctf_field_class_struct *struct_fc = NULL;
1513 struct fs_sink_ctf_field_class_variant *var_fc = NULL;
1514 struct fs_sink_ctf_named_field_class *named_fc;
1515
1516 if (fc_type == FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT) {
1517 struct_fc = (void *) fc;
1518 len = struct_fc->members->len;
1519 } else {
1520 var_fc = (void *) fc;
1521 len = var_fc->options->len;
1522 ret = set_field_ref(fc, fc_name, parent_fc);
1523 if (ret) {
1524 goto end;
1525 }
1526 }
1527
1528 for (i = 0; i < len; i++) {
1529 if (fc_type == FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT) {
1530 named_fc = fs_sink_ctf_field_class_struct_borrow_member_by_index(
1531 struct_fc, i);
1532 } else {
1533 named_fc = fs_sink_ctf_field_class_variant_borrow_option_by_index(
1534 var_fc, i);
1535 }
1536
1537 ret = set_field_refs(named_fc->fc, named_fc->name->str,
1538 fc);
1539 if (ret) {
1540 goto end;
1541 }
1542 }
1543
1544 break;
1545 }
1546 case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY:
1547 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
1548 {
1549 struct fs_sink_ctf_field_class_array_base *array_base_fc =
1550 (void *) fc;
1551
1552 if (fc_type == FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE) {
1553 ret = set_field_ref(fc, fc_name, parent_fc);
1554 if (ret) {
1555 goto end;
1556 }
1557 }
1558
1559 ret = set_field_refs(array_base_fc->elem_fc, NULL, fc);
1560 if (ret) {
1561 goto end;
1562 }
1563
1564 break;
1565 }
1566 default:
1567 break;
1568 }
1569
1570 end:
1571 return ret;
1572 }
1573
1574 /*
1575 * This function translates a root scope trace IR field class to
1576 * a CTF IR field class.
1577 *
1578 * The resulting CTF IR field class is written to `*fc` so that it
1579 * exists as the parent object's (stream class or event class) true root
1580 * field class during the recursive translation for resolving purposes.
1581 * This is also why this function creates the empty structure field
1582 * class and then calls translate_structure_field_class_members() to
1583 * fill it.
1584 */
1585 static
1586 int translate_scope_field_class(struct ctx *ctx, bt_field_path_scope scope,
1587 struct fs_sink_ctf_field_class **fc,
1588 const bt_field_class *ir_fc)
1589 {
1590 int ret = 0;
1591
1592 if (!ir_fc) {
1593 goto end;
1594 }
1595
1596 BT_ASSERT(bt_field_class_get_type(ir_fc) ==
1597 BT_FIELD_CLASS_TYPE_STRUCTURE);
1598 BT_ASSERT(fc);
1599 *fc = (void *) fs_sink_ctf_field_class_struct_create_empty(
1600 ir_fc, UINT64_C(-1));
1601 BT_ASSERT(*fc);
1602 ctx->cur_scope = scope;
1603 BT_ASSERT(ctx->cur_path->len == 0);
1604 ret = cur_path_stack_push(ctx, UINT64_C(-1), NULL, false, ir_fc, NULL);
1605 if (ret) {
1606 BT_COMP_LOGE("Cannot translate scope structure field class: "
1607 "scope=%d", scope);
1608 goto end;
1609 }
1610
1611 ret = translate_structure_field_class_members(ctx, (void *) *fc, ir_fc);
1612 if (ret) {
1613 BT_COMP_LOGE("Cannot translate scope structure field class: "
1614 "scope=%d", scope);
1615 goto end;
1616 }
1617
1618 cur_path_stack_pop(ctx);
1619
1620 /* Set field refs for preceding targets */
1621 ret = set_field_refs(*fc, NULL, NULL);
1622
1623 end:
1624 return ret;
1625 }
1626
1627 static inline
1628 void ctx_init(struct ctx *ctx, struct fs_sink_comp *fs_sink)
1629 {
1630 memset(ctx, 0, sizeof(struct ctx));
1631 ctx->cur_path = g_array_new(FALSE, TRUE,
1632 sizeof(struct field_path_elem));
1633 BT_ASSERT(ctx->cur_path);
1634 ctx->log_level = fs_sink->log_level;
1635 ctx->self_comp = fs_sink->self_comp;
1636 }
1637
1638 static inline
1639 void ctx_fini(struct ctx *ctx)
1640 {
1641 if (ctx->cur_path) {
1642 g_array_free(ctx->cur_path, TRUE);
1643 ctx->cur_path = NULL;
1644 }
1645 }
1646
1647 static
1648 int translate_event_class(struct fs_sink_comp *fs_sink,
1649 struct fs_sink_ctf_stream_class *sc,
1650 const bt_event_class *ir_ec,
1651 struct fs_sink_ctf_event_class **out_ec)
1652 {
1653 int ret = 0;
1654 struct ctx ctx;
1655 struct fs_sink_ctf_event_class *ec;
1656
1657 BT_ASSERT(sc);
1658 BT_ASSERT(ir_ec);
1659
1660 ctx_init(&ctx, fs_sink);
1661 ec = fs_sink_ctf_event_class_create(sc, ir_ec);
1662 BT_ASSERT(ec);
1663 ctx.cur_sc = sc;
1664 ctx.cur_ec = ec;
1665 ret = translate_scope_field_class(&ctx, BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT,
1666 &ec->spec_context_fc,
1667 bt_event_class_borrow_specific_context_field_class_const(
1668 ir_ec));
1669 if (ret) {
1670 goto end;
1671 }
1672
1673 ret = translate_scope_field_class(&ctx, BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD,
1674 &ec->payload_fc,
1675 bt_event_class_borrow_payload_field_class_const(ir_ec));
1676 if (ret) {
1677 goto end;
1678 }
1679
1680 end:
1681 ctx_fini(&ctx);
1682 *out_ec = ec;
1683 return ret;
1684 }
1685
1686 BT_HIDDEN
1687 int try_translate_event_class_trace_ir_to_ctf_ir(
1688 struct fs_sink_comp *fs_sink,
1689 struct fs_sink_ctf_stream_class *sc,
1690 const bt_event_class *ir_ec,
1691 struct fs_sink_ctf_event_class **out_ec)
1692 {
1693 int ret = 0;
1694
1695 BT_ASSERT(sc);
1696 BT_ASSERT(ir_ec);
1697
1698 /* Check in hash table first */
1699 *out_ec = g_hash_table_lookup(sc->event_classes_from_ir, ir_ec);
1700 if (G_LIKELY(*out_ec)) {
1701 goto end;
1702 }
1703
1704 ret = translate_event_class(fs_sink, sc, ir_ec, out_ec);
1705
1706 end:
1707 return ret;
1708 }
1709
1710 bool default_clock_class_name_exists(struct fs_sink_ctf_trace *trace,
1711 const char *name)
1712 {
1713 bool exists = false;
1714 uint64_t i;
1715
1716 for (i = 0; i < trace->stream_classes->len; i++) {
1717 struct fs_sink_ctf_stream_class *sc =
1718 trace->stream_classes->pdata[i];
1719
1720 if (sc->default_clock_class_name->len == 0) {
1721 /* No default clock class */
1722 continue;
1723 }
1724
1725 if (strcmp(sc->default_clock_class_name->str, name) == 0) {
1726 exists = true;
1727 goto end;
1728 }
1729 }
1730
1731 end:
1732 return exists;
1733 }
1734
1735 static
1736 void make_unique_default_clock_class_name(struct fs_sink_ctf_stream_class *sc)
1737 {
1738 unsigned int suffix = 0;
1739 char buf[16];
1740
1741 g_string_assign(sc->default_clock_class_name, "");
1742 sprintf(buf, "default");
1743
1744 while (default_clock_class_name_exists(sc->trace, buf)) {
1745 sprintf(buf, "default%u", suffix);
1746 suffix++;
1747 }
1748
1749 g_string_assign(sc->default_clock_class_name, buf);
1750 }
1751
1752 static
1753 int translate_stream_class(struct fs_sink_comp *fs_sink,
1754 struct fs_sink_ctf_trace *trace,
1755 const bt_stream_class *ir_sc,
1756 struct fs_sink_ctf_stream_class **out_sc)
1757 {
1758 int ret = 0;
1759 struct ctx ctx;
1760
1761 BT_ASSERT(trace);
1762 BT_ASSERT(ir_sc);
1763 ctx_init(&ctx, fs_sink);
1764 *out_sc = fs_sink_ctf_stream_class_create(trace, ir_sc);
1765 BT_ASSERT(*out_sc);
1766
1767 /* Set default clock class's protected name, if any */
1768 if ((*out_sc)->default_clock_class) {
1769 const char *name = bt_clock_class_get_name(
1770 (*out_sc)->default_clock_class);
1771
1772 if (name) {
1773 /* Try original name, protected */
1774 g_string_assign((*out_sc)->default_clock_class_name,
1775 "");
1776
1777 if (must_protect_identifier(name)) {
1778 g_string_assign(
1779 (*out_sc)->default_clock_class_name,
1780 "_");
1781 }
1782
1783 g_string_assign((*out_sc)->default_clock_class_name,
1784 name);
1785 if (!ist_valid_identifier(
1786 (*out_sc)->default_clock_class_name->str)) {
1787 /* Invalid: create a new name */
1788 make_unique_default_clock_class_name(*out_sc);
1789 ret = 0;
1790 }
1791 } else {
1792 /* No name: create a name */
1793 make_unique_default_clock_class_name(*out_sc);
1794 }
1795 }
1796
1797 ctx.cur_sc = *out_sc;
1798 ret = translate_scope_field_class(&ctx, BT_FIELD_PATH_SCOPE_PACKET_CONTEXT,
1799 &(*out_sc)->packet_context_fc,
1800 bt_stream_class_borrow_packet_context_field_class_const(ir_sc));
1801 if (ret) {
1802 goto error;
1803 }
1804
1805 if ((*out_sc)->packet_context_fc) {
1806 /*
1807 * Make sure the structure field class's alignment is
1808 * enough: 8 is what we use for our own special members
1809 * in the packet context.
1810 */
1811 fs_sink_ctf_field_class_struct_align_at_least(
1812 (void *) (*out_sc)->packet_context_fc, 8);
1813 }
1814
1815 ret = translate_scope_field_class(&ctx, BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT,
1816 &(*out_sc)->event_common_context_fc,
1817 bt_stream_class_borrow_event_common_context_field_class_const(
1818 ir_sc));
1819 if (ret) {
1820 goto error;
1821 }
1822
1823 goto end;
1824
1825 error:
1826 fs_sink_ctf_stream_class_destroy(*out_sc);
1827 *out_sc = NULL;
1828
1829 end:
1830 ctx_fini(&ctx);
1831 return ret;
1832 }
1833
1834 BT_HIDDEN
1835 int try_translate_stream_class_trace_ir_to_ctf_ir(
1836 struct fs_sink_comp *fs_sink,
1837 struct fs_sink_ctf_trace *trace,
1838 const bt_stream_class *ir_sc,
1839 struct fs_sink_ctf_stream_class **out_sc)
1840 {
1841 int ret = 0;
1842 uint64_t i;
1843
1844 BT_ASSERT(trace);
1845 BT_ASSERT(ir_sc);
1846
1847 for (i = 0; i < trace->stream_classes->len; i++) {
1848 *out_sc = trace->stream_classes->pdata[i];
1849
1850 if ((*out_sc)->ir_sc == ir_sc) {
1851 goto end;
1852 }
1853 }
1854
1855 ret = translate_stream_class(fs_sink, trace, ir_sc, out_sc);
1856
1857 end:
1858 return ret;
1859 }
1860
1861 BT_HIDDEN
1862 struct fs_sink_ctf_trace *translate_trace_trace_ir_to_ctf_ir(
1863 struct fs_sink_comp *fs_sink, const bt_trace *ir_trace)
1864 {
1865 uint64_t count;
1866 uint64_t i;
1867 struct fs_sink_ctf_trace *trace = NULL;
1868
1869 /* Check that trace's environment is TSDL-compatible */
1870 count = bt_trace_get_environment_entry_count(ir_trace);
1871 for (i = 0; i < count; i++) {
1872 const char *name;
1873 const bt_value *val;
1874
1875 bt_trace_borrow_environment_entry_by_index_const(
1876 ir_trace, i, &name, &val);
1877
1878 if (!ist_valid_identifier(name)) {
1879 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, fs_sink->log_level,
1880 fs_sink->self_comp,
1881 "Unsupported trace class's environment entry name: "
1882 "name=\"%s\"", name);
1883 goto end;
1884 }
1885
1886 switch (bt_value_get_type(val)) {
1887 case BT_VALUE_TYPE_SIGNED_INTEGER:
1888 case BT_VALUE_TYPE_STRING:
1889 break;
1890 default:
1891 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, fs_sink->log_level,
1892 fs_sink->self_comp,
1893 "Unsupported trace class's environment entry value type: "
1894 "type=%s",
1895 bt_common_value_type_string(
1896 bt_value_get_type(val)));
1897 goto end;
1898 }
1899 }
1900
1901 trace = fs_sink_ctf_trace_create(ir_trace);
1902 BT_ASSERT(trace);
1903
1904 end:
1905 return trace;
1906 }
BabelTrace - Trace Format Babel Tower
This page took 0.068867 seconds and 4 git commands to generate.