projects / babeltrace.git / blob
? search:


604388b4cf2e17cf005a05ca9b9ab60911280f8f
[babeltrace.git] / src / plugins / ctf / common / metadata / visitor-generate-ir.c
1 /*
2 * ctf-visitor-generate-ir.c
3 *
4 * Common Trace Format metadata visitor (generates CTF IR objects).
5 *
6 * Based on older ctf-visitor-generate-io-struct.c.
7 *
8 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * Copyright 2015-2018 - Philippe Proulx <philippe.proulx@efficios.com>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this software and associated documentation files (the "Software"), to deal
13 * in the Software without restriction, including without limitation the rights
14 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 * copies of the Software, and to permit persons to whom the Software is
16 * furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 * SOFTWARE.
28 */
29
30 #define BT_COMP_LOG_SELF_COMP (ctx->log_cfg.self_comp)
31 #define BT_LOG_OUTPUT_LEVEL (ctx->log_cfg.log_level)
32 #define BT_LOG_TAG "PLUGIN/CTF/META/IR-VISITOR"
33 #include "logging/comp-logging.h"
34
35 #include <stdio.h>
36 #include <unistd.h>
37 #include <string.h>
38 #include <stdbool.h>
39 #include <stdlib.h>
40 #include <ctype.h>
41 #include "common/assert.h"
42 #include <glib.h>
43 #include <inttypes.h>
44 #include <errno.h>
45 #include "common/common.h"
46 #include "common/uuid.h"
47 #include "compat/endian.h"
48 #include <babeltrace2/babeltrace.h>
49
50 #include "logging.h"
51 #include "scanner.h"
52 #include "ast.h"
53 #include "decoder.h"
54 #include "ctf-meta.h"
55 #include "ctf-meta-visitors.h"
56
57 /* Bit value (left shift) */
58 #define _BV(_val) (1 << (_val))
59
60 /* Bit is set in a set of bits */
61 #define _IS_SET(_set, _mask) (*(_set) & (_mask))
62
63 /* Set bit in a set of bits */
64 #define _SET(_set, _mask) (*(_set) |= (_mask))
65
66 /* Try to push scope, or go to the `error` label */
67 #define _TRY_PUSH_SCOPE_OR_GOTO_ERROR() \
68 do { \
69 ret = ctx_push_scope(ctx); \
70 if (ret) { \
71 BT_COMP_LOGE_STR("Cannot push scope."); \
72 goto error; \
73 } \
74 } while (0)
75
76 /* Bits for verifying existing attributes in various declarations */
77 enum {
78 _CLOCK_NAME_SET = _BV(0),
79 _CLOCK_UUID_SET = _BV(1),
80 _CLOCK_FREQ_SET = _BV(2),
81 _CLOCK_PRECISION_SET = _BV(3),
82 _CLOCK_OFFSET_S_SET = _BV(4),
83 _CLOCK_OFFSET_SET = _BV(5),
84 _CLOCK_ABSOLUTE_SET = _BV(6),
85 _CLOCK_DESCRIPTION_SET = _BV(7),
86 };
87
88 enum {
89 _INTEGER_ALIGN_SET = _BV(0),
90 _INTEGER_SIZE_SET = _BV(1),
91 _INTEGER_BASE_SET = _BV(2),
92 _INTEGER_ENCODING_SET = _BV(3),
93 _INTEGER_BYTE_ORDER_SET = _BV(4),
94 _INTEGER_SIGNED_SET = _BV(5),
95 _INTEGER_MAP_SET = _BV(6),
96 };
97
98 enum {
99 _FLOAT_ALIGN_SET = _BV(0),
100 _FLOAT_MANT_DIG_SET = _BV(1),
101 _FLOAT_EXP_DIG_SET = _BV(2),
102 _FLOAT_BYTE_ORDER_SET = _BV(3),
103 };
104
105 enum {
106 _STRING_ENCODING_SET = _BV(0),
107 };
108
109 enum {
110 _TRACE_MINOR_SET = _BV(0),
111 _TRACE_MAJOR_SET = _BV(1),
112 _TRACE_BYTE_ORDER_SET = _BV(2),
113 _TRACE_UUID_SET = _BV(3),
114 _TRACE_PACKET_HEADER_SET = _BV(4),
115 };
116
117 enum {
118 _STREAM_ID_SET = _BV(0),
119 _STREAM_PACKET_CONTEXT_SET = _BV(1),
120 _STREAM_EVENT_HEADER_SET = _BV(2),
121 _STREAM_EVENT_CONTEXT_SET = _BV(3),
122 };
123
124 enum {
125 _EVENT_NAME_SET = _BV(0),
126 _EVENT_ID_SET = _BV(1),
127 _EVENT_MODEL_EMF_URI_SET = _BV(2),
128 _EVENT_STREAM_ID_SET = _BV(3),
129 _EVENT_LOG_LEVEL_SET = _BV(4),
130 _EVENT_CONTEXT_SET = _BV(5),
131 _EVENT_FIELDS_SET = _BV(6),
132 };
133
134 enum loglevel {
135 LOG_LEVEL_EMERG = 0,
136 LOG_LEVEL_ALERT = 1,
137 LOG_LEVEL_CRIT = 2,
138 LOG_LEVEL_ERR = 3,
139 LOG_LEVEL_WARNING = 4,
140 LOG_LEVEL_NOTICE = 5,
141 LOG_LEVEL_INFO = 6,
142 LOG_LEVEL_DEBUG_SYSTEM = 7,
143 LOG_LEVEL_DEBUG_PROGRAM = 8,
144 LOG_LEVEL_DEBUG_PROCESS = 9,
145 LOG_LEVEL_DEBUG_MODULE = 10,
146 LOG_LEVEL_DEBUG_UNIT = 11,
147 LOG_LEVEL_DEBUG_FUNCTION = 12,
148 LOG_LEVEL_DEBUG_LINE = 13,
149 LOG_LEVEL_DEBUG = 14,
150 _NR_LOGLEVELS = 15,
151 };
152
153 /* Prefixes of class aliases */
154 #define _PREFIX_ALIAS 'a'
155 #define _PREFIX_ENUM 'e'
156 #define _PREFIX_STRUCT 's'
157 #define _PREFIX_VARIANT 'v'
158
159 /* First entry in a BT list */
160 #define _BT_LIST_FIRST_ENTRY(_ptr, _class, _member) \
161 bt_list_entry((_ptr)->next, _class, _member)
162
163 #define _BT_COMP_LOGE_DUP_ATTR(_node, _attr, _entity) \
164 _BT_COMP_LOGE_LINENO((_node)->lineno, \
165 "Duplicate attribute in %s: attr-name=\"%s\"", \
166 _entity, _attr)
167
168 #define _BT_COMP_LOGE_NODE(_node, _msg, args...) \
169 _BT_COMP_LOGE_LINENO((_node)->lineno, _msg, ## args)
170
171 #define _BT_COMP_LOGW_NODE(_node, _msg, args...) \
172 _BT_COMP_LOGW_LINENO((_node)->lineno, _msg, ## args)
173
174 #define _BT_COMP_LOGT_NODE(_node, _msg, args...) \
175 _BT_COMP_LOGT_LINENO((_node)->lineno, _msg, ## args)
176
177 /*
178 * Declaration scope of a visitor context. This represents a TSDL
179 * lexical scope, so that aliases and named structures, variants,
180 * and enumerations may be registered and looked up hierarchically.
181 */
182 struct ctx_decl_scope {
183 /*
184 * Alias name to field class.
185 *
186 * GQuark -> struct ctf_field_class * (owned by this)
187 */
188 GHashTable *decl_map;
189
190 /* Parent scope; NULL if this is the root declaration scope */
191 struct ctx_decl_scope *parent_scope;
192 };
193
194 /*
195 * Visitor context (private).
196 */
197 struct ctx {
198 struct meta_log_config log_cfg;
199
200 /* Trace IR trace class being filled (owned by this) */
201 bt_trace_class *trace_class;
202
203 /* CTF meta trace being filled (owned by this) */
204 struct ctf_trace_class *ctf_tc;
205
206 /* Current declaration scope (top of the stack) (owned by this) */
207 struct ctx_decl_scope *current_scope;
208
209 /* True if trace declaration is visited */
210 bool is_trace_visited;
211
212 /* True if this is an LTTng trace */
213 bool is_lttng;
214
215 /* Config passed by the user */
216 struct ctf_metadata_decoder_config decoder_config;
217 };
218
219 /*
220 * Visitor (public).
221 */
222 struct ctf_visitor_generate_ir;
223
224 /**
225 * Creates a new declaration scope.
226 *
227 * @param par_scope Parent scope (NULL if creating a root scope)
228 * @returns New declaration scope, or NULL on error
229 */
230 static
231 struct ctx_decl_scope *ctx_decl_scope_create(struct ctx *ctx,
232 struct ctx_decl_scope *par_scope)
233 {
234 struct ctx_decl_scope *scope;
235
236 scope = g_new(struct ctx_decl_scope, 1);
237 if (!scope) {
238 BT_COMP_LOGE_STR("Failed to allocate one declaration scope.");
239 goto end;
240 }
241
242 scope->decl_map = g_hash_table_new_full(g_direct_hash, g_direct_equal,
243 NULL, (GDestroyNotify) ctf_field_class_destroy);
244 scope->parent_scope = par_scope;
245
246 end:
247 return scope;
248 }
249
250 /**
251 * Destroys a declaration scope.
252 *
253 * This function does not destroy the parent scope.
254 *
255 * @param scope Scope to destroy
256 */
257 static
258 void ctx_decl_scope_destroy(struct ctx_decl_scope *scope)
259 {
260 if (!scope) {
261 goto end;
262 }
263
264 g_hash_table_destroy(scope->decl_map);
265 g_free(scope);
266
267 end:
268 return;
269 }
270
271 /**
272 * Returns the GQuark of a prefixed alias.
273 *
274 * @param prefix Prefix character
275 * @param name Name
276 * @returns Associated GQuark, or 0 on error
277 */
278 static
279 GQuark get_prefixed_named_quark(struct ctx *ctx, char prefix, const char *name)
280 {
281 GQuark qname = 0;
282
283 BT_ASSERT(name);
284
285 /* Prefix character + original string + '\0' */
286 char *prname = g_new(char, strlen(name) + 2);
287 if (!prname) {
288 BT_COMP_LOGE_STR("Failed to allocate a string.");
289 goto end;
290 }
291
292 sprintf(prname, "%c%s", prefix, name);
293 qname = g_quark_from_string(prname);
294 g_free(prname);
295
296 end:
297 return qname;
298 }
299
300 /**
301 * Looks up a prefixed class alias within a declaration scope.
302 *
303 * @param scope Declaration scope
304 * @param prefix Prefix character
305 * @param name Alias name
306 * @param levels Number of levels to dig into (-1 means infinite)
307 * @param copy True to return a copy
308 * @returns Declaration (owned by caller if \p copy is true),
309 * or NULL if not found
310 */
311 static
312 struct ctf_field_class *ctx_decl_scope_lookup_prefix_alias(
313 struct ctx *ctx, struct ctx_decl_scope *scope, char prefix,
314 const char *name, int levels, bool copy)
315 {
316 GQuark qname = 0;
317 int cur_levels = 0;
318 struct ctf_field_class *decl = NULL;
319 struct ctx_decl_scope *cur_scope = scope;
320
321 BT_ASSERT(scope);
322 BT_ASSERT(name);
323 qname = get_prefixed_named_quark(ctx, prefix, name);
324 if (!qname) {
325 goto end;
326 }
327
328 if (levels < 0) {
329 levels = INT_MAX;
330 }
331
332 while (cur_scope && cur_levels < levels) {
333 decl = g_hash_table_lookup(cur_scope->decl_map,
334 (gconstpointer) GUINT_TO_POINTER(qname));
335 if (decl) {
336 /* Caller's reference */
337 if (copy) {
338 decl = ctf_field_class_copy(decl);
339 BT_ASSERT(decl);
340 }
341
342 goto end;
343 }
344
345 cur_scope = cur_scope->parent_scope;
346 cur_levels++;
347 }
348
349 end:
350 return decl;
351 }
352
353 /**
354 * Looks up a class alias within a declaration scope.
355 *
356 * @param scope Declaration scope
357 * @param name Alias name
358 * @param levels Number of levels to dig into (-1 means infinite)
359 * @param copy True to return a copy
360 * @returns Declaration (owned by caller if \p copy is true),
361 * or NULL if not found
362 */
363 static
364 struct ctf_field_class *ctx_decl_scope_lookup_alias(struct ctx *ctx,
365 struct ctx_decl_scope *scope, const char *name, int levels,
366 bool copy)
367 {
368 return ctx_decl_scope_lookup_prefix_alias(ctx, scope, _PREFIX_ALIAS,
369 name, levels, copy);
370 }
371
372 /**
373 * Looks up an enumeration within a declaration scope.
374 *
375 * @param scope Declaration scope
376 * @param name Enumeration name
377 * @param levels Number of levels to dig into (-1 means infinite)
378 * @param copy True to return a copy
379 * @returns Declaration (owned by caller if \p copy is true),
380 * or NULL if not found
381 */
382 static
383 struct ctf_field_class_enum *ctx_decl_scope_lookup_enum(struct ctx *ctx,
384 struct ctx_decl_scope *scope, const char *name, int levels,
385 bool copy)
386 {
387 return (void *) ctx_decl_scope_lookup_prefix_alias(ctx, scope,
388 _PREFIX_ENUM, name, levels, copy);
389 }
390
391 /**
392 * Looks up a structure within a declaration scope.
393 *
394 * @param scope Declaration scope
395 * @param name Structure name
396 * @param levels Number of levels to dig into (-1 means infinite)
397 * @param copy True to return a copy
398 * @returns Declaration (owned by caller if \p copy is true),
399 * or NULL if not found
400 */
401 static
402 struct ctf_field_class_struct *ctx_decl_scope_lookup_struct(struct ctx *ctx,
403 struct ctx_decl_scope *scope, const char *name, int levels,
404 bool copy)
405 {
406 return (void *) ctx_decl_scope_lookup_prefix_alias(ctx, scope,
407 _PREFIX_STRUCT, name, levels, copy);
408 }
409
410 /**
411 * Looks up a variant within a declaration scope.
412 *
413 * @param scope Declaration scope
414 * @param name Variant name
415 * @param levels Number of levels to dig into (-1 means infinite)
416 * @param copy True to return a copy
417 * @returns Declaration (owned by caller if \p copy is true),
418 * or NULL if not found
419 */
420 static
421 struct ctf_field_class_variant *ctx_decl_scope_lookup_variant(struct ctx *ctx,
422 struct ctx_decl_scope *scope, const char *name, int levels,
423 bool copy)
424 {
425 return (void *) ctx_decl_scope_lookup_prefix_alias(ctx, scope,
426 _PREFIX_VARIANT, name, levels, copy);
427 }
428
429 /**
430 * Registers a prefixed class alias within a declaration scope.
431 *
432 * @param scope Declaration scope
433 * @param prefix Prefix character
434 * @param name Alias name (non-NULL)
435 * @param decl Field class to register (copied)
436 * @returns 0 if registration went okay, negative value otherwise
437 */
438 static
439 int ctx_decl_scope_register_prefix_alias(struct ctx *ctx,
440 struct ctx_decl_scope *scope, char prefix, const char *name,
441 struct ctf_field_class *decl)
442 {
443 int ret = 0;
444 GQuark qname = 0;
445
446 BT_ASSERT(scope);
447 BT_ASSERT(name);
448 BT_ASSERT(decl);
449 qname = get_prefixed_named_quark(ctx, prefix, name);
450 if (!qname) {
451 ret = -ENOMEM;
452 goto end;
453 }
454
455 /* Make sure alias does not exist in local scope */
456 if (ctx_decl_scope_lookup_prefix_alias(ctx, scope, prefix, name, 1,
457 false)) {
458 ret = -EEXIST;
459 goto end;
460 }
461
462 decl = ctf_field_class_copy(decl);
463 BT_ASSERT(decl);
464 g_hash_table_insert(scope->decl_map, GUINT_TO_POINTER(qname), decl);
465
466 end:
467 return ret;
468 }
469
470 /**
471 * Registers a class alias within a declaration scope.
472 *
473 * @param scope Declaration scope
474 * @param name Alias name (non-NULL)
475 * @param decl Field class to register (copied)
476 * @returns 0 if registration went okay, negative value otherwise
477 */
478 static
479 int ctx_decl_scope_register_alias(struct ctx *ctx, struct ctx_decl_scope *scope,
480 const char *name, struct ctf_field_class *decl)
481 {
482 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_ALIAS,
483 name, (void *) decl);
484 }
485
486 /**
487 * Registers an enumeration declaration within a declaration scope.
488 *
489 * @param scope Declaration scope
490 * @param name Enumeration name (non-NULL)
491 * @param decl Enumeration field class to register (copied)
492 * @returns 0 if registration went okay, negative value otherwise
493 */
494 static
495 int ctx_decl_scope_register_enum(struct ctx *ctx, struct ctx_decl_scope *scope,
496 const char *name, struct ctf_field_class_enum *decl)
497 {
498 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_ENUM,
499 name, (void *) decl);
500 }
501
502 /**
503 * Registers a structure declaration within a declaration scope.
504 *
505 * @param scope Declaration scope
506 * @param name Structure name (non-NULL)
507 * @param decl Structure field class to register (copied)
508 * @returns 0 if registration went okay, negative value otherwise
509 */
510 static
511 int ctx_decl_scope_register_struct(struct ctx *ctx,
512 struct ctx_decl_scope *scope, const char *name,
513 struct ctf_field_class_struct *decl)
514 {
515 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_STRUCT,
516 name, (void *) decl);
517 }
518
519 /**
520 * Registers a variant declaration within a declaration scope.
521 *
522 * @param scope Declaration scope
523 * @param name Variant name (non-NULL)
524 * @param decl Variant field class to register
525 * @returns 0 if registration went okay, negative value otherwise
526 */
527 static
528 int ctx_decl_scope_register_variant(struct ctx *ctx,
529 struct ctx_decl_scope *scope, const char *name,
530 struct ctf_field_class_variant *decl)
531 {
532 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_VARIANT,
533 name, (void *) decl);
534 }
535
536 /**
537 * Destroys a visitor context.
538 *
539 * @param ctx Visitor context to destroy
540 */
541 static
542 void ctx_destroy(struct ctx *ctx)
543 {
544 struct ctx_decl_scope *scope;
545
546 if (!ctx) {
547 goto end;
548 }
549
550 scope = ctx->current_scope;
551
552 /*
553 * Destroy all scopes, from current one to the root scope.
554 */
555 while (scope) {
556 struct ctx_decl_scope *parent_scope = scope->parent_scope;
557
558 ctx_decl_scope_destroy(scope);
559 scope = parent_scope;
560 }
561
562 bt_trace_class_put_ref(ctx->trace_class);
563
564 if (ctx->ctf_tc) {
565 ctf_trace_class_destroy(ctx->ctf_tc);
566 }
567
568 g_free(ctx);
569
570 end:
571 return;
572 }
573
574 /**
575 * Creates a new visitor context.
576 *
577 * @param trace Associated trace
578 * @returns New visitor context, or NULL on error
579 */
580 static
581 struct ctx *ctx_create(const struct ctf_metadata_decoder_config *decoder_config)
582 {
583 struct ctx *ctx = NULL;
584
585 BT_ASSERT(decoder_config);
586
587 ctx = g_new0(struct ctx, 1);
588 if (!ctx) {
589 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
590 decoder_config->self_comp,
591 "Failed to allocate one visitor context.");
592 goto error;
593 }
594
595 ctx->log_cfg.log_level = decoder_config->log_level;
596 ctx->log_cfg.self_comp = decoder_config->self_comp;
597
598 if (decoder_config->self_comp) {
599 ctx->trace_class = bt_trace_class_create(
600 decoder_config->self_comp);
601 if (!ctx->trace_class) {
602 BT_COMP_LOGE_STR("Cannot create empty trace class.");
603 goto error;
604 }
605 }
606
607 ctx->ctf_tc = ctf_trace_class_create();
608 if (!ctx->ctf_tc) {
609 BT_COMP_LOGE_STR("Cannot create CTF trace class.");
610 goto error;
611 }
612
613 /* Root declaration scope */
614 ctx->current_scope = ctx_decl_scope_create(ctx, NULL);
615 if (!ctx->current_scope) {
616 BT_COMP_LOGE_STR("Cannot create declaration scope.");
617 goto error;
618 }
619
620 ctx->decoder_config = *decoder_config;
621 goto end;
622
623 error:
624 ctx_destroy(ctx);
625 ctx = NULL;
626
627 end:
628 return ctx;
629 }
630
631 /**
632 * Pushes a new declaration scope on top of a visitor context's
633 * declaration scope stack.
634 *
635 * @param ctx Visitor context
636 * @returns 0 on success, or a negative value on error
637 */
638 static
639 int ctx_push_scope(struct ctx *ctx)
640 {
641 int ret = 0;
642 struct ctx_decl_scope *new_scope;
643
644 BT_ASSERT(ctx);
645 new_scope = ctx_decl_scope_create(ctx, ctx->current_scope);
646 if (!new_scope) {
647 BT_COMP_LOGE_STR("Cannot create declaration scope.");
648 ret = -ENOMEM;
649 goto end;
650 }
651
652 ctx->current_scope = new_scope;
653
654 end:
655 return ret;
656 }
657
658 static
659 void ctx_pop_scope(struct ctx *ctx)
660 {
661 struct ctx_decl_scope *parent_scope = NULL;
662
663 BT_ASSERT(ctx);
664
665 if (!ctx->current_scope) {
666 goto end;
667 }
668
669 parent_scope = ctx->current_scope->parent_scope;
670 ctx_decl_scope_destroy(ctx->current_scope);
671 ctx->current_scope = parent_scope;
672
673 end:
674 return;
675 }
676
677 static
678 int visit_field_class_specifier_list(struct ctx *ctx, struct ctf_node *ts_list,
679 struct ctf_field_class **decl);
680
681 static
682 int is_unary_string(struct bt_list_head *head)
683 {
684 int ret = TRUE;
685 struct ctf_node *node;
686
687 bt_list_for_each_entry(node, head, siblings) {
688 if (node->type != NODE_UNARY_EXPRESSION) {
689 ret = FALSE;
690 }
691
692 if (node->u.unary_expression.type != UNARY_STRING) {
693 ret = FALSE;
694 }
695 }
696
697 return ret;
698 }
699
700 static
701 const char *get_map_clock_name_value(struct bt_list_head *head)
702 {
703 int i = 0;
704 struct ctf_node *node;
705 const char *name = NULL;
706
707 bt_list_for_each_entry(node, head, siblings) {
708 char *src_string;
709 int uexpr_type = node->u.unary_expression.type;
710 int uexpr_link = node->u.unary_expression.link;
711 int cond = node->type != NODE_UNARY_EXPRESSION ||
712 uexpr_type != UNARY_STRING ||
713 !((uexpr_link != UNARY_LINK_UNKNOWN) ^ (i == 0));
714 if (cond) {
715 goto error;
716 }
717
718 /* Needs to be chained with . */
719 switch (node->u.unary_expression.link) {
720 case UNARY_DOTLINK:
721 break;
722 case UNARY_ARROWLINK:
723 case UNARY_DOTDOTDOT:
724 goto error;
725 default:
726 break;
727 }
728
729 src_string = node->u.unary_expression.u.string;
730
731 switch (i) {
732 case 0:
733 if (strcmp("clock", src_string)) {
734 goto error;
735 }
736 break;
737 case 1:
738 name = src_string;
739 break;
740 case 2:
741 if (strcmp("value", src_string)) {
742 goto error;
743 }
744 break;
745 default:
746 /* Extra identifier, unknown */
747 goto error;
748 }
749
750 i++;
751 }
752
753 return name;
754
755 error:
756 return NULL;
757 }
758
759 static
760 int is_unary_unsigned(struct bt_list_head *head)
761 {
762 int ret = TRUE;
763 struct ctf_node *node;
764
765 bt_list_for_each_entry(node, head, siblings) {
766 if (node->type != NODE_UNARY_EXPRESSION) {
767 ret = FALSE;
768 }
769
770 if (node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
771 ret = FALSE;
772 }
773 }
774
775 return ret;
776 }
777
778 static
779 int get_unary_unsigned(struct ctx *ctx, struct bt_list_head *head,
780 uint64_t *value)
781 {
782 int i = 0;
783 int ret = 0;
784 struct ctf_node *node;
785
786 *value = 0;
787
788 if (bt_list_empty(head)) {
789 ret = -1;
790 goto end;
791 }
792
793 bt_list_for_each_entry(node, head, siblings) {
794 int uexpr_type = node->u.unary_expression.type;
795 int uexpr_link = node->u.unary_expression.link;
796 int cond = node->type != NODE_UNARY_EXPRESSION ||
797 uexpr_type != UNARY_UNSIGNED_CONSTANT ||
798 uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
799 if (cond) {
800 _BT_COMP_LOGE_NODE(node, "Invalid constant unsigned integer.");
801 ret = -EINVAL;
802 goto end;
803 }
804
805 *value = node->u.unary_expression.u.unsigned_constant;
806 i++;
807 }
808
809 end:
810 return ret;
811 }
812
813 static
814 int is_unary_signed(struct bt_list_head *head)
815 {
816 int ret = TRUE;
817 struct ctf_node *node;
818
819 bt_list_for_each_entry(node, head, siblings) {
820 if (node->type != NODE_UNARY_EXPRESSION) {
821 ret = FALSE;
822 }
823
824 if (node->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
825 ret = FALSE;
826 }
827 }
828
829 return ret;
830 }
831
832 static
833 int get_unary_signed(struct bt_list_head *head, int64_t *value)
834 {
835 int i = 0;
836 int ret = 0;
837 struct ctf_node *node;
838
839 bt_list_for_each_entry(node, head, siblings) {
840 int uexpr_type = node->u.unary_expression.type;
841 int uexpr_link = node->u.unary_expression.link;
842 int cond = node->type != NODE_UNARY_EXPRESSION ||
843 (uexpr_type != UNARY_UNSIGNED_CONSTANT &&
844 uexpr_type != UNARY_SIGNED_CONSTANT) ||
845 uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
846 if (cond) {
847 ret = -EINVAL;
848 goto end;
849 }
850
851 switch (uexpr_type) {
852 case UNARY_UNSIGNED_CONSTANT:
853 *value = (int64_t)
854 node->u.unary_expression.u.unsigned_constant;
855 break;
856 case UNARY_SIGNED_CONSTANT:
857 *value = node->u.unary_expression.u.signed_constant;
858 break;
859 default:
860 ret = -EINVAL;
861 goto end;
862 }
863
864 i++;
865 }
866
867 end:
868 return ret;
869 }
870
871 static
872 int get_unary_uuid(struct ctx *ctx, struct bt_list_head *head,
873 bt_uuid_t uuid)
874 {
875 return ctf_ast_get_unary_uuid(head, uuid, ctx->log_cfg.log_level,
876 ctx->log_cfg.self_comp);
877 }
878
879 static
880 int get_boolean(struct ctx *ctx, struct ctf_node *unary_expr)
881 {
882 int ret = 0;
883
884 if (unary_expr->type != NODE_UNARY_EXPRESSION) {
885 _BT_COMP_LOGE_NODE(unary_expr,
886 "Expecting unary expression: node-type=%d",
887 unary_expr->type);
888 ret = -EINVAL;
889 goto end;
890 }
891
892 switch (unary_expr->u.unary_expression.type) {
893 case UNARY_UNSIGNED_CONSTANT:
894 ret = (unary_expr->u.unary_expression.u.unsigned_constant != 0);
895 break;
896 case UNARY_SIGNED_CONSTANT:
897 ret = (unary_expr->u.unary_expression.u.signed_constant != 0);
898 break;
899 case UNARY_STRING:
900 {
901 const char *str = unary_expr->u.unary_expression.u.string;
902
903 if (strcmp(str, "true") == 0 || strcmp(str, "TRUE") == 0) {
904 ret = TRUE;
905 } else if (strcmp(str, "false") == 0 || strcmp(str, "FALSE") == 0) {
906 ret = FALSE;
907 } else {
908 _BT_COMP_LOGE_NODE(unary_expr,
909 "Unexpected boolean value: value=\"%s\"", str);
910 ret = -EINVAL;
911 goto end;
912 }
913 break;
914 }
915 default:
916 _BT_COMP_LOGE_NODE(unary_expr,
917 "Unexpected unary expression type: node-type=%d",
918 unary_expr->u.unary_expression.type);
919 ret = -EINVAL;
920 goto end;
921 }
922
923 end:
924 return ret;
925 }
926
927 static
928 enum ctf_byte_order byte_order_from_unary_expr(struct ctx *ctx,
929 struct ctf_node *unary_expr)
930 {
931 const char *str;
932 enum ctf_byte_order bo = CTF_BYTE_ORDER_UNKNOWN;
933
934 if (unary_expr->u.unary_expression.type != UNARY_STRING) {
935 _BT_COMP_LOGE_NODE(unary_expr,
936 "\"byte_order\" attribute: expecting `be`, `le`, `network`, or `native`.");
937 goto end;
938 }
939
940 str = unary_expr->u.unary_expression.u.string;
941
942 if (strcmp(str, "be") == 0 || strcmp(str, "network") == 0) {
943 bo = CTF_BYTE_ORDER_BIG;
944 } else if (strcmp(str, "le") == 0) {
945 bo = CTF_BYTE_ORDER_LITTLE;
946 } else if (strcmp(str, "native") == 0) {
947 bo = CTF_BYTE_ORDER_DEFAULT;
948 } else {
949 _BT_COMP_LOGE_NODE(unary_expr,
950 "Unexpected \"byte_order\" attribute value: "
951 "expecting `be`, `le`, `network`, or `native`: value=\"%s\"",
952 str);
953 goto end;
954 }
955
956 end:
957 return bo;
958 }
959
960 static
961 enum ctf_byte_order get_real_byte_order(struct ctx *ctx,
962 struct ctf_node *uexpr)
963 {
964 enum ctf_byte_order bo = byte_order_from_unary_expr(ctx, uexpr);
965
966 if (bo == CTF_BYTE_ORDER_DEFAULT) {
967 bo = ctx->ctf_tc->default_byte_order;
968 }
969
970 return bo;
971 }
972
973 static
974 int is_align_valid(uint64_t align)
975 {
976 return (align != 0) && !(align & (align - UINT64_C(1)));
977 }
978
979 static
980 int get_class_specifier_name(struct ctx *ctx, struct ctf_node *cls_specifier,
981 GString *str)
982 {
983 int ret = 0;
984
985 if (cls_specifier->type != NODE_TYPE_SPECIFIER) {
986 _BT_COMP_LOGE_NODE(cls_specifier,
987 "Unexpected node type: node-type=%d",
988 cls_specifier->type);
989 ret = -EINVAL;
990 goto end;
991 }
992
993 switch (cls_specifier->u.field_class_specifier.type) {
994 case TYPESPEC_VOID:
995 g_string_append(str, "void");
996 break;
997 case TYPESPEC_CHAR:
998 g_string_append(str, "char");
999 break;
1000 case TYPESPEC_SHORT:
1001 g_string_append(str, "short");
1002 break;
1003 case TYPESPEC_INT:
1004 g_string_append(str, "int");
1005 break;
1006 case TYPESPEC_LONG:
1007 g_string_append(str, "long");
1008 break;
1009 case TYPESPEC_FLOAT:
1010 g_string_append(str, "float");
1011 break;
1012 case TYPESPEC_DOUBLE:
1013 g_string_append(str, "double");
1014 break;
1015 case TYPESPEC_SIGNED:
1016 g_string_append(str, "signed");
1017 break;
1018 case TYPESPEC_UNSIGNED:
1019 g_string_append(str, "unsigned");
1020 break;
1021 case TYPESPEC_BOOL:
1022 g_string_append(str, "bool");
1023 break;
1024 case TYPESPEC_COMPLEX:
1025 g_string_append(str, "_Complex");
1026 break;
1027 case TYPESPEC_IMAGINARY:
1028 g_string_append(str, "_Imaginary");
1029 break;
1030 case TYPESPEC_CONST:
1031 g_string_append(str, "const");
1032 break;
1033 case TYPESPEC_ID_TYPE:
1034 if (cls_specifier->u.field_class_specifier.id_type) {
1035 g_string_append(str,
1036 cls_specifier->u.field_class_specifier.id_type);
1037 }
1038 break;
1039 case TYPESPEC_STRUCT:
1040 {
1041 struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
1042
1043 if (!node->u._struct.name) {
1044 _BT_COMP_LOGE_NODE(node, "Unexpected empty structure field class name.");
1045 ret = -EINVAL;
1046 goto end;
1047 }
1048
1049 g_string_append(str, "struct ");
1050 g_string_append(str, node->u._struct.name);
1051 break;
1052 }
1053 case TYPESPEC_VARIANT:
1054 {
1055 struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
1056
1057 if (!node->u.variant.name) {
1058 _BT_COMP_LOGE_NODE(node, "Unexpected empty variant field class name.");
1059 ret = -EINVAL;
1060 goto end;
1061 }
1062
1063 g_string_append(str, "variant ");
1064 g_string_append(str, node->u.variant.name);
1065 break;
1066 }
1067 case TYPESPEC_ENUM:
1068 {
1069 struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
1070
1071 if (!node->u._enum.enum_id) {
1072 _BT_COMP_LOGE_NODE(node,
1073 "Unexpected empty enumeration field class (`enum`) name.");
1074 ret = -EINVAL;
1075 goto end;
1076 }
1077
1078 g_string_append(str, "enum ");
1079 g_string_append(str, node->u._enum.enum_id);
1080 break;
1081 }
1082 case TYPESPEC_FLOATING_POINT:
1083 case TYPESPEC_INTEGER:
1084 case TYPESPEC_STRING:
1085 default:
1086 _BT_COMP_LOGE_NODE(cls_specifier->u.field_class_specifier.node,
1087 "Unexpected field class specifier type: %d",
1088 cls_specifier->u.field_class_specifier.type);
1089 ret = -EINVAL;
1090 goto end;
1091 }
1092
1093 end:
1094 return ret;
1095 }
1096
1097 static
1098 int get_class_specifier_list_name(struct ctx *ctx,
1099 struct ctf_node *cls_specifier_list, GString *str)
1100 {
1101 int ret = 0;
1102 struct ctf_node *iter;
1103 int alias_item_nr = 0;
1104 struct bt_list_head *head =
1105 &cls_specifier_list->u.field_class_specifier_list.head;
1106
1107 bt_list_for_each_entry(iter, head, siblings) {
1108 if (alias_item_nr != 0) {
1109 g_string_append(str, " ");
1110 }
1111
1112 alias_item_nr++;
1113 ret = get_class_specifier_name(ctx, iter, str);
1114 if (ret) {
1115 goto end;
1116 }
1117 }
1118
1119 end:
1120 return ret;
1121 }
1122
1123 static
1124 GQuark create_class_alias_identifier(struct ctx *ctx,
1125 struct ctf_node *cls_specifier_list,
1126 struct ctf_node *node_field_class_declarator)
1127 {
1128 int ret;
1129 char *str_c;
1130 GString *str;
1131 GQuark qalias = 0;
1132 struct ctf_node *iter;
1133 struct bt_list_head *pointers =
1134 &node_field_class_declarator->u.field_class_declarator.pointers;
1135
1136 str = g_string_new("");
1137 ret = get_class_specifier_list_name(ctx, cls_specifier_list, str);
1138 if (ret) {
1139 g_string_free(str, TRUE);
1140 goto end;
1141 }
1142
1143 bt_list_for_each_entry(iter, pointers, siblings) {
1144 g_string_append(str, " *");
1145
1146 if (iter->u.pointer.const_qualifier) {
1147 g_string_append(str, " const");
1148 }
1149 }
1150
1151 str_c = g_string_free(str, FALSE);
1152 qalias = g_quark_from_string(str_c);
1153 g_free(str_c);
1154
1155 end:
1156 return qalias;
1157 }
1158
1159 static
1160 int visit_field_class_declarator(struct ctx *ctx,
1161 struct ctf_node *cls_specifier_list,
1162 GQuark *field_name, struct ctf_node *node_field_class_declarator,
1163 struct ctf_field_class **field_decl,
1164 struct ctf_field_class *nested_decl)
1165 {
1166 /*
1167 * During this whole function, nested_decl is always OURS,
1168 * whereas field_decl is an output which we create, but
1169 * belongs to the caller (it is moved).
1170 */
1171 int ret = 0;
1172 *field_decl = NULL;
1173
1174 /* Validate field class declarator node */
1175 if (node_field_class_declarator) {
1176 if (node_field_class_declarator->u.field_class_declarator.type ==
1177 TYPEDEC_UNKNOWN) {
1178 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1179 "Unexpected field class declarator type: type=%d",
1180 node_field_class_declarator->u.field_class_declarator.type);
1181 ret = -EINVAL;
1182 goto error;
1183 }
1184
1185 /* TODO: GCC bitfields not supported yet */
1186 if (node_field_class_declarator->u.field_class_declarator.bitfield_len !=
1187 NULL) {
1188 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1189 "GCC bitfields are not supported as of this version.");
1190 ret = -EPERM;
1191 goto error;
1192 }
1193 }
1194
1195 /* Find the right nested declaration if not provided */
1196 if (!nested_decl) {
1197 struct bt_list_head *pointers =
1198 &node_field_class_declarator->u.field_class_declarator.pointers;
1199
1200 if (node_field_class_declarator && !bt_list_empty(pointers)) {
1201 GQuark qalias;
1202
1203 /*
1204 * If we have a pointer declarator, it HAS to
1205 * be present in the field class aliases (else
1206 * fail).
1207 */
1208 qalias = create_class_alias_identifier(ctx,
1209 cls_specifier_list, node_field_class_declarator);
1210 nested_decl =
1211 ctx_decl_scope_lookup_alias(ctx,
1212 ctx->current_scope,
1213 g_quark_to_string(qalias), -1, true);
1214 if (!nested_decl) {
1215 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1216 "Cannot find class alias: name=\"%s\"",
1217 g_quark_to_string(qalias));
1218 ret = -EINVAL;
1219 goto error;
1220 }
1221
1222 if (nested_decl->type == CTF_FIELD_CLASS_TYPE_INT) {
1223 /* Pointer: force integer's base to 16 */
1224 struct ctf_field_class_int *int_fc =
1225 (void *) nested_decl;
1226
1227 int_fc->disp_base =
1228 BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
1229 }
1230 } else {
1231 ret = visit_field_class_specifier_list(ctx,
1232 cls_specifier_list, &nested_decl);
1233 if (ret) {
1234 BT_ASSERT(!nested_decl);
1235 goto error;
1236 }
1237 }
1238 }
1239
1240 BT_ASSERT(nested_decl);
1241
1242 if (!node_field_class_declarator) {
1243 *field_decl = nested_decl;
1244 nested_decl = NULL;
1245 goto end;
1246 }
1247
1248 if (node_field_class_declarator->u.field_class_declarator.type == TYPEDEC_ID) {
1249 if (node_field_class_declarator->u.field_class_declarator.u.id) {
1250 const char *id =
1251 node_field_class_declarator->u.field_class_declarator.u.id;
1252
1253 *field_name = g_quark_from_string(id);
1254 } else {
1255 *field_name = 0;
1256 }
1257
1258 *field_decl = nested_decl;
1259 nested_decl = NULL;
1260 goto end;
1261 } else {
1262 struct ctf_node *first;
1263 struct ctf_field_class *decl = NULL;
1264 struct ctf_field_class *outer_field_decl = NULL;
1265 struct bt_list_head *length =
1266 &node_field_class_declarator->
1267 u.field_class_declarator.u.nested.length;
1268
1269 /* Create array/sequence, pass nested_decl as child */
1270 if (bt_list_empty(length)) {
1271 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1272 "Expecting length field reference or value.");
1273 ret = -EINVAL;
1274 goto error;
1275 }
1276
1277 first = _BT_LIST_FIRST_ENTRY(length, struct ctf_node, siblings);
1278 if (first->type != NODE_UNARY_EXPRESSION) {
1279 _BT_COMP_LOGE_NODE(first,
1280 "Unexpected node type: node-type=%d",
1281 first->type);
1282 ret = -EINVAL;
1283 goto error;
1284 }
1285
1286 switch (first->u.unary_expression.type) {
1287 case UNARY_UNSIGNED_CONSTANT:
1288 {
1289 struct ctf_field_class_array *array_decl = NULL;
1290
1291 array_decl = ctf_field_class_array_create();
1292 BT_ASSERT(array_decl);
1293 array_decl->length =
1294 first->u.unary_expression.u.unsigned_constant;
1295 array_decl->base.elem_fc = nested_decl;
1296 nested_decl = NULL;
1297 decl = (void *) array_decl;
1298 break;
1299 }
1300 case UNARY_STRING:
1301 {
1302 /* Lookup unsigned integer definition, create seq. */
1303 struct ctf_field_class_sequence *seq_decl = NULL;
1304 char *length_name = ctf_ast_concatenate_unary_strings(length);
1305
1306 if (!length_name) {
1307 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1308 "Cannot concatenate unary strings.");
1309 ret = -EINVAL;
1310 goto error;
1311 }
1312
1313 if (strncmp(length_name, "env.", 4) == 0) {
1314 /* This is, in fact, an array */
1315 const char *env_entry_name = &length_name[4];
1316 struct ctf_trace_class_env_entry *env_entry =
1317 ctf_trace_class_borrow_env_entry_by_name(
1318 ctx->ctf_tc, env_entry_name);
1319 struct ctf_field_class_array *array_decl;
1320
1321 if (!env_entry) {
1322 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1323 "Cannot find environment entry: "
1324 "name=\"%s\"", env_entry_name);
1325 ret = -EINVAL;
1326 goto error;
1327 }
1328
1329 if (env_entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1330 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1331 "Wrong environment entry type "
1332 "(expecting integer): "
1333 "name=\"%s\"", env_entry_name);
1334 ret = -EINVAL;
1335 goto error;
1336 }
1337
1338 if (env_entry->value.i < 0) {
1339 _BT_COMP_LOGE_NODE(node_field_class_declarator,
1340 "Invalid, negative array length: "
1341 "env-entry-name=\"%s\", "
1342 "value=%" PRId64,
1343 env_entry_name,
1344 env_entry->value.i);
1345 ret = -EINVAL;
1346 goto error;
1347 }
1348
1349 array_decl = ctf_field_class_array_create();
1350 BT_ASSERT(array_decl);
1351 array_decl->length =
1352 (uint64_t) env_entry->value.i;
1353 array_decl->base.elem_fc = nested_decl;
1354 nested_decl = NULL;
1355 decl = (void *) array_decl;
1356 } else {
1357 seq_decl = ctf_field_class_sequence_create();
1358 BT_ASSERT(seq_decl);
1359 seq_decl->base.elem_fc = nested_decl;
1360 nested_decl = NULL;
1361 g_string_assign(seq_decl->length_ref,
1362 length_name);
1363 decl = (void *) seq_decl;
1364 }
1365
1366 g_free(length_name);
1367 break;
1368 }
1369 default:
1370 ret = -EINVAL;
1371 goto error;
1372 }
1373
1374 BT_ASSERT(!nested_decl);
1375 BT_ASSERT(decl);
1376 BT_ASSERT(!*field_decl);
1377
1378 /*
1379 * At this point, we found the next nested declaration.
1380 * We currently own this (and lost the ownership of
1381 * nested_decl in the meantime). Pass this next
1382 * nested declaration as the content of the outer
1383 * container, MOVING its ownership.
1384 */
1385 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1386 field_name,
1387 node_field_class_declarator->
1388 u.field_class_declarator.u.nested.field_class_declarator,
1389 &outer_field_decl, decl);
1390 decl = NULL;
1391 if (ret) {
1392 BT_ASSERT(!outer_field_decl);
1393 ret = -EINVAL;
1394 goto error;
1395 }
1396
1397 BT_ASSERT(outer_field_decl);
1398 *field_decl = outer_field_decl;
1399 outer_field_decl = NULL;
1400 }
1401
1402 BT_ASSERT(*field_decl);
1403 goto end;
1404
1405 error:
1406 ctf_field_class_destroy(*field_decl);
1407 *field_decl = NULL;
1408
1409 if (ret >= 0) {
1410 ret = -1;
1411 }
1412
1413 end:
1414 ctf_field_class_destroy(nested_decl);
1415 nested_decl = NULL;
1416 return ret;
1417 }
1418
1419 static
1420 int visit_struct_decl_field(struct ctx *ctx,
1421 struct ctf_field_class_struct *struct_decl,
1422 struct ctf_node *cls_specifier_list,
1423 struct bt_list_head *field_class_declarators)
1424 {
1425 int ret = 0;
1426 struct ctf_node *iter;
1427 struct ctf_field_class *field_decl = NULL;
1428
1429 bt_list_for_each_entry(iter, field_class_declarators, siblings) {
1430 field_decl = NULL;
1431 GQuark qfield_name;
1432 const char *field_name;
1433
1434 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1435 &qfield_name, iter, &field_decl, NULL);
1436 if (ret) {
1437 BT_ASSERT(!field_decl);
1438 _BT_COMP_LOGE_NODE(cls_specifier_list,
1439 "Cannot visit field class declarator: ret=%d", ret);
1440 goto error;
1441 }
1442
1443 BT_ASSERT(field_decl);
1444 field_name = g_quark_to_string(qfield_name);
1445
1446 /* Check if field with same name already exists */
1447 if (ctf_field_class_struct_borrow_member_by_name(
1448 struct_decl, field_name)) {
1449 _BT_COMP_LOGE_NODE(cls_specifier_list,
1450 "Duplicate field in structure field class: "
1451 "field-name=\"%s\"", field_name);
1452 ret = -EINVAL;
1453 goto error;
1454 }
1455
1456 /* Add field to structure */
1457 ctf_field_class_struct_append_member(struct_decl,
1458 field_name, field_decl);
1459 field_decl = NULL;
1460 }
1461
1462 return 0;
1463
1464 error:
1465 ctf_field_class_destroy(field_decl);
1466 field_decl = NULL;
1467 return ret;
1468 }
1469
1470 static
1471 int visit_variant_decl_field(struct ctx *ctx,
1472 struct ctf_field_class_variant *variant_decl,
1473 struct ctf_node *cls_specifier_list,
1474 struct bt_list_head *field_class_declarators)
1475 {
1476 int ret = 0;
1477 struct ctf_node *iter;
1478 struct ctf_field_class *field_decl = NULL;
1479
1480 bt_list_for_each_entry(iter, field_class_declarators, siblings) {
1481 field_decl = NULL;
1482 GQuark qfield_name;
1483 const char *field_name;
1484
1485 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1486 &qfield_name, iter, &field_decl, NULL);
1487 if (ret) {
1488 BT_ASSERT(!field_decl);
1489 _BT_COMP_LOGE_NODE(cls_specifier_list,
1490 "Cannot visit field class declarator: ret=%d", ret);
1491 goto error;
1492 }
1493
1494 BT_ASSERT(field_decl);
1495 field_name = g_quark_to_string(qfield_name);
1496
1497 /* Check if field with same name already exists */
1498 if (ctf_field_class_variant_borrow_option_by_name(
1499 variant_decl, field_name)) {
1500 _BT_COMP_LOGE_NODE(cls_specifier_list,
1501 "Duplicate field in variant field class: "
1502 "field-name=\"%s\"", field_name);
1503 ret = -EINVAL;
1504 goto error;
1505 }
1506
1507 /* Add field to structure */
1508 ctf_field_class_variant_append_option(variant_decl,
1509 field_name, field_decl);
1510 field_decl = NULL;
1511 }
1512
1513 return 0;
1514
1515 error:
1516 ctf_field_class_destroy(field_decl);
1517 field_decl = NULL;
1518 return ret;
1519 }
1520
1521 static
1522 int visit_field_class_def(struct ctx *ctx, struct ctf_node *cls_specifier_list,
1523 struct bt_list_head *field_class_declarators)
1524 {
1525 int ret = 0;
1526 GQuark qidentifier;
1527 struct ctf_node *iter;
1528 struct ctf_field_class *class_decl = NULL;
1529
1530 bt_list_for_each_entry(iter, field_class_declarators, siblings) {
1531 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1532 &qidentifier, iter, &class_decl, NULL);
1533 if (ret) {
1534 _BT_COMP_LOGE_NODE(iter,
1535 "Cannot visit field class declarator: ret=%d", ret);
1536 ret = -EINVAL;
1537 goto end;
1538 }
1539
1540 /* Do not allow field class def and alias of untagged variants */
1541 if (class_decl->type == CTF_FIELD_CLASS_TYPE_VARIANT) {
1542 struct ctf_field_class_variant *var_fc =
1543 (void *) class_decl;
1544
1545 if (var_fc->tag_path.path->len == 0) {
1546 _BT_COMP_LOGE_NODE(iter,
1547 "Type definition of untagged variant field class is not allowed.");
1548 ret = -EPERM;
1549 goto end;
1550 }
1551 }
1552
1553 ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
1554 g_quark_to_string(qidentifier), class_decl);
1555 if (ret) {
1556 _BT_COMP_LOGE_NODE(iter,
1557 "Cannot register field class alias: name=\"%s\"",
1558 g_quark_to_string(qidentifier));
1559 goto end;
1560 }
1561 }
1562
1563 end:
1564 ctf_field_class_destroy(class_decl);
1565 class_decl = NULL;
1566 return ret;
1567 }
1568
1569 static
1570 int visit_field_class_alias(struct ctx *ctx, struct ctf_node *target,
1571 struct ctf_node *alias)
1572 {
1573 int ret = 0;
1574 GQuark qalias;
1575 struct ctf_node *node;
1576 GQuark qdummy_field_name;
1577 struct ctf_field_class *class_decl = NULL;
1578
1579 /* Create target field class */
1580 if (bt_list_empty(&target->u.field_class_alias_target.field_class_declarators)) {
1581 node = NULL;
1582 } else {
1583 node = _BT_LIST_FIRST_ENTRY(
1584 &target->u.field_class_alias_target.field_class_declarators,
1585 struct ctf_node, siblings);
1586 }
1587
1588 ret = visit_field_class_declarator(ctx,
1589 target->u.field_class_alias_target.field_class_specifier_list,
1590 &qdummy_field_name, node, &class_decl, NULL);
1591 if (ret) {
1592 BT_ASSERT(!class_decl);
1593 _BT_COMP_LOGE_NODE(node,
1594 "Cannot visit field class declarator: ret=%d", ret);
1595 goto end;
1596 }
1597
1598 /* Do not allow field class def and alias of untagged variants */
1599 if (class_decl->type == CTF_FIELD_CLASS_TYPE_VARIANT) {
1600 struct ctf_field_class_variant *var_fc = (void *) class_decl;
1601
1602 if (var_fc->tag_path.path->len == 0) {
1603 _BT_COMP_LOGE_NODE(target,
1604 "Type definition of untagged variant field class is not allowed.");
1605 ret = -EPERM;
1606 goto end;
1607 }
1608 }
1609
1610 /*
1611 * The semantic validator does not check whether the target is
1612 * abstract or not (if it has an identifier). Check it here.
1613 */
1614 if (qdummy_field_name != 0) {
1615 _BT_COMP_LOGE_NODE(target,
1616 "Expecting empty identifier: id=\"%s\"",
1617 g_quark_to_string(qdummy_field_name));
1618 ret = -EINVAL;
1619 goto end;
1620 }
1621
1622 /* Create alias identifier */
1623 node = _BT_LIST_FIRST_ENTRY(&alias->u.field_class_alias_name.field_class_declarators,
1624 struct ctf_node, siblings);
1625 qalias = create_class_alias_identifier(ctx,
1626 alias->u.field_class_alias_name.field_class_specifier_list, node);
1627 ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
1628 g_quark_to_string(qalias), class_decl);
1629 if (ret) {
1630 _BT_COMP_LOGE_NODE(node,
1631 "Cannot register class alias: name=\"%s\"",
1632 g_quark_to_string(qalias));
1633 goto end;
1634 }
1635
1636 end:
1637 ctf_field_class_destroy(class_decl);
1638 class_decl = NULL;
1639 return ret;
1640 }
1641
1642 static
1643 int visit_struct_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
1644 struct ctf_field_class_struct *struct_decl)
1645 {
1646 int ret = 0;
1647
1648 switch (entry_node->type) {
1649 case NODE_TYPEDEF:
1650 ret = visit_field_class_def(ctx,
1651 entry_node->u.field_class_def.field_class_specifier_list,
1652 &entry_node->u.field_class_def.field_class_declarators);
1653 if (ret) {
1654 _BT_COMP_LOGE_NODE(entry_node,
1655 "Cannot add field class found in structure field class: ret=%d",
1656 ret);
1657 goto end;
1658 }
1659 break;
1660 case NODE_TYPEALIAS:
1661 ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
1662 entry_node->u.field_class_alias.alias);
1663 if (ret) {
1664 _BT_COMP_LOGE_NODE(entry_node,
1665 "Cannot add field class alias found in structure field class: ret=%d",
1666 ret);
1667 goto end;
1668 }
1669 break;
1670 case NODE_STRUCT_OR_VARIANT_DECLARATION:
1671 /* Field */
1672 ret = visit_struct_decl_field(ctx, struct_decl,
1673 entry_node->u.struct_or_variant_declaration.
1674 field_class_specifier_list,
1675 &entry_node->u.struct_or_variant_declaration.
1676 field_class_declarators);
1677 if (ret) {
1678 goto end;
1679 }
1680 break;
1681 default:
1682 _BT_COMP_LOGE_NODE(entry_node,
1683 "Unexpected node type: node-type=%d", entry_node->type);
1684 ret = -EINVAL;
1685 goto end;
1686 }
1687
1688 end:
1689 return ret;
1690 }
1691
1692 static
1693 int visit_variant_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
1694 struct ctf_field_class_variant *variant_decl)
1695 {
1696 int ret = 0;
1697
1698 switch (entry_node->type) {
1699 case NODE_TYPEDEF:
1700 ret = visit_field_class_def(ctx,
1701 entry_node->u.field_class_def.field_class_specifier_list,
1702 &entry_node->u.field_class_def.field_class_declarators);
1703 if (ret) {
1704 _BT_COMP_LOGE_NODE(entry_node,
1705 "Cannot add field class found in variant field class: ret=%d",
1706 ret);
1707 goto end;
1708 }
1709 break;
1710 case NODE_TYPEALIAS:
1711 ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
1712 entry_node->u.field_class_alias.alias);
1713 if (ret) {
1714 _BT_COMP_LOGE_NODE(entry_node,
1715 "Cannot add field class alias found in variant field class: ret=%d",
1716 ret);
1717 goto end;
1718 }
1719 break;
1720 case NODE_STRUCT_OR_VARIANT_DECLARATION:
1721 /* Field */
1722 ret = visit_variant_decl_field(ctx, variant_decl,
1723 entry_node->u.struct_or_variant_declaration.
1724 field_class_specifier_list,
1725 &entry_node->u.struct_or_variant_declaration.
1726 field_class_declarators);
1727 if (ret) {
1728 goto end;
1729 }
1730 break;
1731 default:
1732 _BT_COMP_LOGE_NODE(entry_node,
1733 "Unexpected node type: node-type=%d",
1734 entry_node->type);
1735 ret = -EINVAL;
1736 goto end;
1737 }
1738
1739 end:
1740 return ret;
1741 }
1742
1743 static
1744 int visit_struct_decl(struct ctx *ctx, const char *name,
1745 struct bt_list_head *decl_list, int has_body,
1746 struct bt_list_head *min_align,
1747 struct ctf_field_class_struct **struct_decl)
1748 {
1749 int ret = 0;
1750
1751 BT_ASSERT(struct_decl);
1752 *struct_decl = NULL;
1753
1754 /* For named struct (without body), lookup in declaration scope */
1755 if (!has_body) {
1756 if (!name) {
1757 BT_COMP_LOGE_STR("Bodyless structure field class: missing name.");
1758 ret = -EPERM;
1759 goto error;
1760 }
1761
1762 *struct_decl = ctx_decl_scope_lookup_struct(ctx, ctx->current_scope,
1763 name, -1, true);
1764 if (!*struct_decl) {
1765 BT_COMP_LOGE("Cannot find structure field class: name=\"struct %s\"",
1766 name);
1767 ret = -EINVAL;
1768 goto error;
1769 }
1770 } else {
1771 struct ctf_node *entry_node;
1772 uint64_t min_align_value = 0;
1773
1774 if (name) {
1775 if (ctx_decl_scope_lookup_struct(ctx,
1776 ctx->current_scope, name, 1, false)) {
1777 BT_COMP_LOGE("Structure field class already declared in local scope: "
1778 "name=\"struct %s\"", name);
1779 ret = -EINVAL;
1780 goto error;
1781 }
1782 }
1783
1784 if (!bt_list_empty(min_align)) {
1785 ret = get_unary_unsigned(ctx, min_align,
1786 &min_align_value);
1787 if (ret) {
1788 BT_COMP_LOGE("Unexpected unary expression for structure field class's `align` attribute: "
1789 "ret=%d", ret);
1790 goto error;
1791 }
1792 }
1793
1794 *struct_decl = ctf_field_class_struct_create();
1795 BT_ASSERT(*struct_decl);
1796
1797 if (min_align_value != 0) {
1798 (*struct_decl)->base.alignment = min_align_value;
1799 }
1800
1801 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
1802
1803 bt_list_for_each_entry(entry_node, decl_list, siblings) {
1804 ret = visit_struct_decl_entry(ctx, entry_node,
1805 *struct_decl);
1806 if (ret) {
1807 _BT_COMP_LOGE_NODE(entry_node,
1808 "Cannot visit structure field class entry: "
1809 "ret=%d", ret);
1810 ctx_pop_scope(ctx);
1811 goto error;
1812 }
1813 }
1814
1815 ctx_pop_scope(ctx);
1816
1817 if (name) {
1818 ret = ctx_decl_scope_register_struct(ctx,
1819 ctx->current_scope, name, *struct_decl);
1820 if (ret) {
1821 BT_COMP_LOGE("Cannot register structure field class in declaration scope: "
1822 "name=\"struct %s\", ret=%d", name, ret);
1823 goto error;
1824 }
1825 }
1826 }
1827
1828 return 0;
1829
1830 error:
1831 ctf_field_class_destroy((void *) *struct_decl);
1832 *struct_decl = NULL;
1833 return ret;
1834 }
1835
1836 static
1837 int visit_variant_decl(struct ctx *ctx, const char *name,
1838 const char *tag, struct bt_list_head *decl_list,
1839 int has_body, struct ctf_field_class_variant **variant_decl)
1840 {
1841 int ret = 0;
1842 struct ctf_field_class_variant *untagged_variant_decl = NULL;
1843
1844 BT_ASSERT(variant_decl);
1845 *variant_decl = NULL;
1846
1847 /* For named variant (without body), lookup in declaration scope */
1848 if (!has_body) {
1849 if (!name) {
1850 BT_COMP_LOGE_STR("Bodyless variant field class: missing name.");
1851 ret = -EPERM;
1852 goto error;
1853 }
1854
1855 untagged_variant_decl =
1856 ctx_decl_scope_lookup_variant(ctx, ctx->current_scope,
1857 name, -1, true);
1858 if (!untagged_variant_decl) {
1859 BT_COMP_LOGE("Cannot find variant field class: name=\"variant %s\"",
1860 name);
1861 ret = -EINVAL;
1862 goto error;
1863 }
1864 } else {
1865 struct ctf_node *entry_node;
1866
1867 if (name) {
1868 if (ctx_decl_scope_lookup_variant(ctx,
1869 ctx->current_scope, name, 1, false)) {
1870 BT_COMP_LOGE("Variant field class already declared in local scope: "
1871 "name=\"variant %s\"", name);
1872 ret = -EINVAL;
1873 goto error;
1874 }
1875 }
1876
1877 untagged_variant_decl = ctf_field_class_variant_create();
1878 BT_ASSERT(untagged_variant_decl);
1879 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
1880
1881 bt_list_for_each_entry(entry_node, decl_list, siblings) {
1882 ret = visit_variant_decl_entry(ctx, entry_node,
1883 untagged_variant_decl);
1884 if (ret) {
1885 _BT_COMP_LOGE_NODE(entry_node,
1886 "Cannot visit variant field class entry: "
1887 "ret=%d", ret);
1888 ctx_pop_scope(ctx);
1889 goto error;
1890 }
1891 }
1892
1893 ctx_pop_scope(ctx);
1894
1895 if (name) {
1896 ret = ctx_decl_scope_register_variant(ctx,
1897 ctx->current_scope, name,
1898 untagged_variant_decl);
1899 if (ret) {
1900 BT_COMP_LOGE("Cannot register variant field class in declaration scope: "
1901 "name=\"variant %s\", ret=%d", name, ret);
1902 goto error;
1903 }
1904 }
1905 }
1906
1907 /*
1908 * If tagged, create tagged variant and return; otherwise
1909 * return untagged variant.
1910 */
1911 if (!tag) {
1912 *variant_decl = untagged_variant_decl;
1913 untagged_variant_decl = NULL;
1914 } else {
1915 /*
1916 * At this point, we have a fresh untagged variant; nobody
1917 * else owns it. Set its tag now.
1918 */
1919 g_string_assign(untagged_variant_decl->tag_ref, tag);
1920 *variant_decl = untagged_variant_decl;
1921 untagged_variant_decl = NULL;
1922 }
1923
1924 BT_ASSERT(!untagged_variant_decl);
1925 BT_ASSERT(*variant_decl);
1926 return 0;
1927
1928 error:
1929 ctf_field_class_destroy((void *) untagged_variant_decl);
1930 untagged_variant_decl = NULL;
1931 ctf_field_class_destroy((void *) *variant_decl);
1932 *variant_decl = NULL;
1933 return ret;
1934 }
1935
1936 struct uori {
1937 bool is_signed;
1938 union {
1939 uint64_t u;
1940 uint64_t i;
1941 } value;
1942 };
1943
1944 static
1945 int visit_enum_decl_entry(struct ctx *ctx, struct ctf_node *enumerator,
1946 struct ctf_field_class_enum *enum_decl, struct uori *last)
1947 {
1948 int ret = 0;
1949 int nr_vals = 0;
1950 struct ctf_node *iter;
1951 struct uori start = {
1952 .is_signed = false,
1953 .value.u = 0,
1954 };
1955 struct uori end = {
1956 .is_signed = false,
1957 .value.u = 0,
1958 };
1959 const char *label = enumerator->u.enumerator.id;
1960 struct bt_list_head *values = &enumerator->u.enumerator.values;
1961
1962 bt_list_for_each_entry(iter, values, siblings) {
1963 struct uori *target;
1964
1965 if (iter->type != NODE_UNARY_EXPRESSION) {
1966 _BT_COMP_LOGE_NODE(iter,
1967 "Wrong expression for enumeration field class label: "
1968 "node-type=%d, label=\"%s\"", iter->type,
1969 label);
1970 ret = -EINVAL;
1971 goto error;
1972 }
1973
1974 if (nr_vals == 0) {
1975 target = &start;
1976 } else {
1977 target = &end;
1978 }
1979
1980 switch (iter->u.unary_expression.type) {
1981 case UNARY_SIGNED_CONSTANT:
1982 target->is_signed = true;
1983 target->value.i =
1984 iter->u.unary_expression.u.signed_constant;
1985 break;
1986 case UNARY_UNSIGNED_CONSTANT:
1987 target->is_signed = false;
1988 target->value.u =
1989 iter->u.unary_expression.u.unsigned_constant;
1990 break;
1991 default:
1992 _BT_COMP_LOGE_NODE(iter,
1993 "Invalid enumeration field class entry: "
1994 "expecting constant signed or unsigned integer: "
1995 "node-type=%d, label=\"%s\"",
1996 iter->u.unary_expression.type, label);
1997 ret = -EINVAL;
1998 goto error;
1999 }
2000
2001 if (nr_vals > 1) {
2002 _BT_COMP_LOGE_NODE(iter,
2003 "Invalid enumeration field class entry: label=\"%s\"",
2004 label);
2005 ret = -EINVAL;
2006 goto error;
2007 }
2008
2009 nr_vals++;
2010 }
2011
2012 if (nr_vals == 0) {
2013 start = *last;
2014 }
2015
2016 if (nr_vals <= 1) {
2017 end = start;
2018 }
2019
2020 if (end.is_signed) {
2021 last->value.i = end.value.i + 1;
2022 } else {
2023 last->value.u = end.value.u + 1;
2024 }
2025
2026 ctf_field_class_enum_map_range(enum_decl, label,
2027 start.value.u, end.value.u);
2028 return 0;
2029
2030 error:
2031 return ret;
2032 }
2033
2034 static
2035 int visit_enum_decl(struct ctx *ctx, const char *name,
2036 struct ctf_node *container_cls,
2037 struct bt_list_head *enumerator_list,
2038 int has_body, struct ctf_field_class_enum **enum_decl)
2039 {
2040 int ret = 0;
2041 GQuark qdummy_id;
2042 struct ctf_field_class_int *integer_decl = NULL;
2043
2044 BT_ASSERT(enum_decl);
2045 *enum_decl = NULL;
2046
2047 /* For named enum (without body), lookup in declaration scope */
2048 if (!has_body) {
2049 if (!name) {
2050 BT_COMP_LOGE_STR("Bodyless enumeration field class: missing name.");
2051 ret = -EPERM;
2052 goto error;
2053 }
2054
2055 *enum_decl = ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
2056 name, -1, true);
2057 if (!*enum_decl) {
2058 BT_COMP_LOGE("Cannot find enumeration field class: "
2059 "name=\"enum %s\"", name);
2060 ret = -EINVAL;
2061 goto error;
2062 }
2063 } else {
2064 struct ctf_node *iter;
2065 struct uori last_value = {
2066 .is_signed = false,
2067 .value.u = 0,
2068 };
2069
2070 if (name) {
2071 if (ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
2072 name, 1, false)) {
2073 BT_COMP_LOGE("Enumeration field class already declared in local scope: "
2074 "name=\"enum %s\"", name);
2075 ret = -EINVAL;
2076 goto error;
2077 }
2078 }
2079
2080 if (!container_cls) {
2081 integer_decl = (void *) ctx_decl_scope_lookup_alias(ctx,
2082 ctx->current_scope, "int", -1, true);
2083 if (!integer_decl) {
2084 BT_COMP_LOGE_STR("Cannot find implicit `int` field class alias for enumeration field class.");
2085 ret = -EINVAL;
2086 goto error;
2087 }
2088 } else {
2089 ret = visit_field_class_declarator(ctx, container_cls,
2090 &qdummy_id, NULL, (void *) &integer_decl,
2091 NULL);
2092 if (ret) {
2093 BT_ASSERT(!integer_decl);
2094 ret = -EINVAL;
2095 goto error;
2096 }
2097 }
2098
2099 BT_ASSERT(integer_decl);
2100
2101 if (integer_decl->base.base.type != CTF_FIELD_CLASS_TYPE_INT) {
2102 BT_COMP_LOGE("Container field class for enumeration field class is not an integer field class: "
2103 "fc-type=%d", integer_decl->base.base.type);
2104 ret = -EINVAL;
2105 goto error;
2106 }
2107
2108 *enum_decl = ctf_field_class_enum_create();
2109 BT_ASSERT(*enum_decl);
2110 (*enum_decl)->base.base.base.alignment =
2111 integer_decl->base.base.alignment;
2112 ctf_field_class_int_copy_content((void *) *enum_decl,
2113 (void *) integer_decl);
2114 last_value.is_signed = (*enum_decl)->base.is_signed;
2115
2116 bt_list_for_each_entry(iter, enumerator_list, siblings) {
2117 ret = visit_enum_decl_entry(ctx, iter, *enum_decl,
2118 &last_value);
2119 if (ret) {
2120 _BT_COMP_LOGE_NODE(iter,
2121 "Cannot visit enumeration field class entry: "
2122 "ret=%d", ret);
2123 goto error;
2124 }
2125 }
2126
2127 if (name) {
2128 ret = ctx_decl_scope_register_enum(ctx,
2129 ctx->current_scope, name, *enum_decl);
2130 if (ret) {
2131 BT_COMP_LOGE("Cannot register enumeration field class in declaration scope: "
2132 "ret=%d", ret);
2133 goto error;
2134 }
2135 }
2136 }
2137
2138 goto end;
2139
2140 error:
2141 ctf_field_class_destroy((void *) *enum_decl);
2142 *enum_decl = NULL;
2143
2144 end:
2145 ctf_field_class_destroy((void *) integer_decl);
2146 integer_decl = NULL;
2147 return ret;
2148 }
2149
2150 static
2151 int visit_field_class_specifier(struct ctx *ctx,
2152 struct ctf_node *cls_specifier_list,
2153 struct ctf_field_class **decl)
2154 {
2155 int ret = 0;
2156 GString *str = NULL;
2157
2158 *decl = NULL;
2159 str = g_string_new("");
2160 ret = get_class_specifier_list_name(ctx, cls_specifier_list, str);
2161 if (ret) {
2162 _BT_COMP_LOGE_NODE(cls_specifier_list,
2163 "Cannot get field class specifier list's name: ret=%d", ret);
2164 goto error;
2165 }
2166
2167 *decl = ctx_decl_scope_lookup_alias(ctx, ctx->current_scope, str->str,
2168 -1, true);
2169 if (!*decl) {
2170 _BT_COMP_LOGE_NODE(cls_specifier_list,
2171 "Cannot find field class alias: name=\"%s\"", str->str);
2172 ret = -EINVAL;
2173 goto error;
2174 }
2175
2176 goto end;
2177
2178 error:
2179 ctf_field_class_destroy(*decl);
2180 *decl = NULL;
2181
2182 end:
2183 if (str) {
2184 g_string_free(str, TRUE);
2185 }
2186
2187 return ret;
2188 }
2189
2190 static
2191 int visit_integer_decl(struct ctx *ctx,
2192 struct bt_list_head *expressions,
2193 struct ctf_field_class_int **integer_decl)
2194 {
2195 int set = 0;
2196 int ret = 0;
2197 int signedness = 0;
2198 struct ctf_node *expression;
2199 uint64_t alignment = 0, size = 0;
2200 struct ctf_clock_class *mapped_clock_class = NULL;
2201 enum ctf_encoding encoding = CTF_ENCODING_NONE;
2202 bt_field_class_integer_preferred_display_base base =
2203 BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
2204 enum ctf_byte_order byte_order = ctx->ctf_tc->default_byte_order;
2205
2206 *integer_decl = NULL;
2207
2208 bt_list_for_each_entry(expression, expressions, siblings) {
2209 struct ctf_node *left, *right;
2210
2211 left = _BT_LIST_FIRST_ENTRY(&expression->u.ctf_expression.left,
2212 struct ctf_node, siblings);
2213 right = _BT_LIST_FIRST_ENTRY(
2214 &expression->u.ctf_expression.right, struct ctf_node,
2215 siblings);
2216
2217 if (left->u.unary_expression.type != UNARY_STRING) {
2218 _BT_COMP_LOGE_NODE(left,
2219 "Unexpected unary expression type: type=%d",
2220 left->u.unary_expression.type);
2221 ret = -EINVAL;
2222 goto error;
2223 }
2224
2225 if (strcmp(left->u.unary_expression.u.string, "signed") == 0) {
2226 if (_IS_SET(&set, _INTEGER_SIGNED_SET)) {
2227 _BT_COMP_LOGE_DUP_ATTR(left, "signed",
2228 "integer field class");
2229 ret = -EPERM;
2230 goto error;
2231 }
2232
2233 signedness = get_boolean(ctx, right);
2234 if (signedness < 0) {
2235 _BT_COMP_LOGE_NODE(right,
2236 "Invalid boolean value for integer field class's `signed` attribute: "
2237 "ret=%d", ret);
2238 ret = -EINVAL;
2239 goto error;
2240 }
2241
2242 _SET(&set, _INTEGER_SIGNED_SET);
2243 } else if (strcmp(left->u.unary_expression.u.string, "byte_order") == 0) {
2244 if (_IS_SET(&set, _INTEGER_BYTE_ORDER_SET)) {
2245 _BT_COMP_LOGE_DUP_ATTR(left, "byte_order",
2246 "integer field class");
2247 ret = -EPERM;
2248 goto error;
2249 }
2250
2251 byte_order = get_real_byte_order(ctx, right);
2252 if (byte_order == CTF_BYTE_ORDER_UNKNOWN) {
2253 _BT_COMP_LOGE_NODE(right,
2254 "Invalid `byte_order` attribute in integer field class: "
2255 "ret=%d", ret);
2256 ret = -EINVAL;
2257 goto error;
2258 }
2259
2260 _SET(&set, _INTEGER_BYTE_ORDER_SET);
2261 } else if (strcmp(left->u.unary_expression.u.string, "size") == 0) {
2262 if (_IS_SET(&set, _INTEGER_SIZE_SET)) {
2263 _BT_COMP_LOGE_DUP_ATTR(left, "size",
2264 "integer field class");
2265 ret = -EPERM;
2266 goto error;
2267 }
2268
2269 if (right->u.unary_expression.type !=
2270 UNARY_UNSIGNED_CONSTANT) {
2271 _BT_COMP_LOGE_NODE(right,
2272 "Invalid `size` attribute in integer field class: "
2273 "expecting unsigned constant integer: "
2274 "node-type=%d",
2275 right->u.unary_expression.type);
2276 ret = -EINVAL;
2277 goto error;
2278 }
2279
2280 size = right->u.unary_expression.u.unsigned_constant;
2281 if (size == 0) {
2282 _BT_COMP_LOGE_NODE(right,
2283 "Invalid `size` attribute in integer field class: "
2284 "expecting positive constant integer: "
2285 "size=%" PRIu64, size);
2286 ret = -EINVAL;
2287 goto error;
2288 } else if (size > 64) {
2289 _BT_COMP_LOGE_NODE(right,
2290 "Invalid `size` attribute in integer field class: "
2291 "integer fields over 64 bits are not supported as of this version: "
2292 "size=%" PRIu64, size);
2293 ret = -EINVAL;
2294 goto error;
2295 }
2296
2297 _SET(&set, _INTEGER_SIZE_SET);
2298 } else if (strcmp(left->u.unary_expression.u.string, "align") == 0) {
2299 if (_IS_SET(&set, _INTEGER_ALIGN_SET)) {
2300 _BT_COMP_LOGE_DUP_ATTR(left, "align",
2301 "integer field class");
2302 ret = -EPERM;
2303 goto error;
2304 }
2305
2306 if (right->u.unary_expression.type !=
2307 UNARY_UNSIGNED_CONSTANT) {
2308 _BT_COMP_LOGE_NODE(right,
2309 "Invalid `align` attribute in integer field class: "
2310 "expecting unsigned constant integer: "
2311 "node-type=%d",
2312 right->u.unary_expression.type);
2313 ret = -EINVAL;
2314 goto error;
2315 }
2316
2317 alignment =
2318 right->u.unary_expression.u.unsigned_constant;
2319 if (!is_align_valid(alignment)) {
2320 _BT_COMP_LOGE_NODE(right,
2321 "Invalid `align` attribute in integer field class: "
2322 "expecting power of two: "
2323 "align=%" PRIu64, alignment);
2324 ret = -EINVAL;
2325 goto error;
2326 }
2327
2328 _SET(&set, _INTEGER_ALIGN_SET);
2329 } else if (strcmp(left->u.unary_expression.u.string, "base") == 0) {
2330 if (_IS_SET(&set, _INTEGER_BASE_SET)) {
2331 _BT_COMP_LOGE_DUP_ATTR(left, "base",
2332 "integer field class");
2333 ret = -EPERM;
2334 goto error;
2335 }
2336
2337 switch (right->u.unary_expression.type) {
2338 case UNARY_UNSIGNED_CONSTANT:
2339 {
2340 uint64_t constant = right->u.unary_expression.
2341 u.unsigned_constant;
2342
2343 switch (constant) {
2344 case 2:
2345 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY;
2346 break;
2347 case 8:
2348 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL;
2349 break;
2350 case 10:
2351 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
2352 break;
2353 case 16:
2354 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
2355 break;
2356 default:
2357 _BT_COMP_LOGE_NODE(right,
2358 "Invalid `base` attribute in integer field class: "
2359 "base=%" PRIu64,
2360 right->u.unary_expression.u.unsigned_constant);
2361 ret = -EINVAL;
2362 goto error;
2363 }
2364 break;
2365 }
2366 case UNARY_STRING:
2367 {
2368 char *s_right = ctf_ast_concatenate_unary_strings(
2369 &expression->u.ctf_expression.right);
2370 if (!s_right) {
2371 _BT_COMP_LOGE_NODE(right,
2372 "Unexpected unary expression for integer field class's `base` attribute.");
2373 ret = -EINVAL;
2374 goto error;
2375 }
2376
2377 if (strcmp(s_right, "decimal") == 0 ||
2378 strcmp(s_right, "dec") == 0 ||
2379 strcmp(s_right, "d") == 0 ||
2380 strcmp(s_right, "i") == 0 ||
2381 strcmp(s_right, "u") == 0) {
2382 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
2383 } else if (strcmp(s_right, "hexadecimal") == 0 ||
2384 strcmp(s_right, "hex") == 0 ||
2385 strcmp(s_right, "x") == 0 ||
2386 strcmp(s_right, "X") == 0 ||
2387 strcmp(s_right, "p") == 0) {
2388 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
2389 } else if (strcmp(s_right, "octal") == 0 ||
2390 strcmp(s_right, "oct") == 0 ||
2391 strcmp(s_right, "o") == 0) {
2392 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL;
2393 } else if (strcmp(s_right, "binary") == 0 ||
2394 strcmp(s_right, "b") == 0) {
2395 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY;
2396 } else {
2397 _BT_COMP_LOGE_NODE(right,
2398 "Unexpected unary expression for integer field class's `base` attribute: "
2399 "base=\"%s\"", s_right);
2400 g_free(s_right);
2401 ret = -EINVAL;
2402 goto error;
2403 }
2404
2405 g_free(s_right);
2406 break;
2407 }
2408 default:
2409 _BT_COMP_LOGE_NODE(right,
2410 "Invalid `base` attribute in integer field class: "
2411 "expecting unsigned constant integer or unary string.");
2412 ret = -EINVAL;
2413 goto error;
2414 }
2415
2416 _SET(&set, _INTEGER_BASE_SET);
2417 } else if (strcmp(left->u.unary_expression.u.string, "encoding") == 0) {
2418 char *s_right;
2419
2420 if (_IS_SET(&set, _INTEGER_ENCODING_SET)) {
2421 _BT_COMP_LOGE_DUP_ATTR(left, "encoding",
2422 "integer field class");
2423 ret = -EPERM;
2424 goto error;
2425 }
2426
2427 if (right->u.unary_expression.type != UNARY_STRING) {
2428 _BT_COMP_LOGE_NODE(right,
2429 "Invalid `encoding` attribute in integer field class: "
2430 "expecting unary string.");
2431 ret = -EINVAL;
2432 goto error;
2433 }
2434
2435 s_right = ctf_ast_concatenate_unary_strings(
2436 &expression->u.ctf_expression.right);
2437 if (!s_right) {
2438 _BT_COMP_LOGE_NODE(right,
2439 "Unexpected unary expression for integer field class's `encoding` attribute.");
2440 ret = -EINVAL;
2441 goto error;
2442 }
2443
2444 if (strcmp(s_right, "UTF8") == 0 ||
2445 strcmp(s_right, "utf8") == 0 ||
2446 strcmp(s_right, "utf-8") == 0 ||
2447 strcmp(s_right, "UTF-8") == 0 ||
2448 strcmp(s_right, "ASCII") == 0 ||
2449 strcmp(s_right, "ascii") == 0) {
2450 encoding = CTF_ENCODING_UTF8;
2451 } else if (strcmp(s_right, "none") == 0) {
2452 encoding = CTF_ENCODING_NONE;
2453 } else {
2454 _BT_COMP_LOGE_NODE(right,
2455 "Invalid `encoding` attribute in integer field class: "
2456 "unknown encoding: encoding=\"%s\"",
2457 s_right);
2458 g_free(s_right);
2459 ret = -EINVAL;
2460 goto error;
2461 }
2462
2463 g_free(s_right);
2464 _SET(&set, _INTEGER_ENCODING_SET);
2465 } else if (strcmp(left->u.unary_expression.u.string, "map") == 0) {
2466 const char *clock_name;
2467
2468 if (_IS_SET(&set, _INTEGER_MAP_SET)) {
2469 _BT_COMP_LOGE_DUP_ATTR(left, "map",
2470 "integer field class");
2471 ret = -EPERM;
2472 goto error;
2473 }
2474
2475 if (right->u.unary_expression.type != UNARY_STRING) {
2476 _BT_COMP_LOGE_NODE(right,
2477 "Invalid `map` attribute in integer field class: "
2478 "expecting unary string.");
2479 ret = -EINVAL;
2480 goto error;
2481 }
2482
2483 clock_name =
2484 get_map_clock_name_value(
2485 &expression->u.ctf_expression.right);
2486 if (!clock_name) {
2487 char *s_right = ctf_ast_concatenate_unary_strings(
2488 &expression->u.ctf_expression.right);
2489
2490 if (!s_right) {
2491 _BT_COMP_LOGE_NODE(right,
2492 "Unexpected unary expression for integer field class's `map` attribute.");
2493 ret = -EINVAL;
2494 goto error;
2495 }
2496
2497 _BT_COMP_LOGE_NODE(right,
2498 "Invalid `map` attribute in integer field class: "
2499 "cannot find clock class at this point: name=\"%s\"",
2500 s_right);
2501 _SET(&set, _INTEGER_MAP_SET);
2502 g_free(s_right);
2503 continue;
2504 }
2505
2506 mapped_clock_class =
2507 ctf_trace_class_borrow_clock_class_by_name(
2508 ctx->ctf_tc, clock_name);
2509 if (!mapped_clock_class) {
2510 _BT_COMP_LOGE_NODE(right,
2511 "Invalid `map` attribute in integer field class: "
2512 "cannot find clock class at this point: name=\"%s\"",
2513 clock_name);
2514 ret = -EINVAL;
2515 goto error;
2516 }
2517
2518 _SET(&set, _INTEGER_MAP_SET);
2519 } else {
2520 _BT_COMP_LOGW_NODE(left,
2521 "Unknown attribute in integer field class: "
2522 "attr-name=\"%s\"",
2523 left->u.unary_expression.u.string);
2524 }
2525 }
2526
2527 if (!_IS_SET(&set, _INTEGER_SIZE_SET)) {
2528 BT_COMP_LOGE_STR("Missing `size` attribute in integer field class.");
2529 ret = -EPERM;
2530 goto error;
2531 }
2532
2533 if (!_IS_SET(&set, _INTEGER_ALIGN_SET)) {
2534 if (size % CHAR_BIT) {
2535 /* Bit-packed alignment */
2536 alignment = 1;
2537 } else {
2538 /* Byte-packed alignment */
2539 alignment = CHAR_BIT;
2540 }
2541 }
2542
2543 *integer_decl = ctf_field_class_int_create();
2544 BT_ASSERT(*integer_decl);
2545 (*integer_decl)->base.base.alignment = alignment;
2546 (*integer_decl)->base.byte_order = byte_order;
2547 (*integer_decl)->base.size = size;
2548 (*integer_decl)->is_signed = (signedness > 0);
2549 (*integer_decl)->disp_base = base;
2550 (*integer_decl)->encoding = encoding;
2551 (*integer_decl)->mapped_clock_class = mapped_clock_class;
2552 return 0;
2553
2554 error:
2555 ctf_field_class_destroy((void *) *integer_decl);
2556 *integer_decl = NULL;
2557 return ret;
2558 }
2559
2560 static
2561 int visit_floating_point_number_decl(struct ctx *ctx,
2562 struct bt_list_head *expressions,
2563 struct ctf_field_class_float **float_decl)
2564 {
2565 int set = 0;
2566 int ret = 0;
2567 struct ctf_node *expression;
2568 uint64_t alignment = 1, exp_dig = 0, mant_dig = 0;
2569 enum ctf_byte_order byte_order = ctx->ctf_tc->default_byte_order;
2570
2571 *float_decl = NULL;
2572
2573 bt_list_for_each_entry(expression, expressions, siblings) {
2574 struct ctf_node *left, *right;
2575
2576 left = _BT_LIST_FIRST_ENTRY(&expression->u.ctf_expression.left,
2577 struct ctf_node, siblings);
2578 right = _BT_LIST_FIRST_ENTRY(
2579 &expression->u.ctf_expression.right, struct ctf_node,
2580 siblings);
2581
2582 if (left->u.unary_expression.type != UNARY_STRING) {
2583 _BT_COMP_LOGE_NODE(left,
2584 "Unexpected unary expression type: type=%d",
2585 left->u.unary_expression.type);
2586 ret = -EINVAL;
2587 goto error;
2588 }
2589
2590 if (strcmp(left->u.unary_expression.u.string, "byte_order") == 0) {
2591 if (_IS_SET(&set, _FLOAT_BYTE_ORDER_SET)) {
2592 _BT_COMP_LOGE_DUP_ATTR(left, "byte_order",
2593 "floating point number field class");
2594 ret = -EPERM;
2595 goto error;
2596 }
2597
2598 byte_order = get_real_byte_order(ctx, right);
2599 if (byte_order == CTF_BYTE_ORDER_UNKNOWN) {
2600 _BT_COMP_LOGE_NODE(right,
2601 "Invalid `byte_order` attribute in floating point number field class: "
2602 "ret=%d", ret);
2603 ret = -EINVAL;
2604 goto error;
2605 }
2606
2607 _SET(&set, _FLOAT_BYTE_ORDER_SET);
2608 } else if (strcmp(left->u.unary_expression.u.string, "exp_dig") == 0) {
2609 if (_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
2610 _BT_COMP_LOGE_DUP_ATTR(left, "exp_dig",
2611 "floating point number field class");
2612 ret = -EPERM;
2613 goto error;
2614 }
2615
2616 if (right->u.unary_expression.type !=
2617 UNARY_UNSIGNED_CONSTANT) {
2618 _BT_COMP_LOGE_NODE(right,
2619 "Invalid `exp_dig` attribute in floating point number field class: "
2620 "expecting unsigned constant integer: "
2621 "node-type=%d",
2622 right->u.unary_expression.type);
2623 ret = -EINVAL;
2624 goto error;
2625 }
2626
2627 exp_dig = right->u.unary_expression.u.unsigned_constant;
2628 _SET(&set, _FLOAT_EXP_DIG_SET);
2629 } else if (strcmp(left->u.unary_expression.u.string, "mant_dig") == 0) {
2630 if (_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
2631 _BT_COMP_LOGE_DUP_ATTR(left, "mant_dig",
2632 "floating point number field class");
2633 ret = -EPERM;
2634 goto error;
2635 }
2636
2637 if (right->u.unary_expression.type !=
2638 UNARY_UNSIGNED_CONSTANT) {
2639 _BT_COMP_LOGE_NODE(right,
2640 "Invalid `mant_dig` attribute in floating point number field class: "
2641 "expecting unsigned constant integer: "
2642 "node-type=%d",
2643 right->u.unary_expression.type);
2644 ret = -EINVAL;
2645 goto error;
2646 }
2647
2648 mant_dig = right->u.unary_expression.u.
2649 unsigned_constant;
2650 _SET(&set, _FLOAT_MANT_DIG_SET);
2651 } else if (strcmp(left->u.unary_expression.u.string, "align") == 0) {
2652 if (_IS_SET(&set, _FLOAT_ALIGN_SET)) {
2653 _BT_COMP_LOGE_DUP_ATTR(left, "align",
2654 "floating point number field class");
2655 ret = -EPERM;
2656 goto error;
2657 }
2658
2659 if (right->u.unary_expression.type !=
2660 UNARY_UNSIGNED_CONSTANT) {
2661 _BT_COMP_LOGE_NODE(right,
2662 "Invalid `align` attribute in floating point number field class: "
2663 "expecting unsigned constant integer: "
2664 "node-type=%d",
2665 right->u.unary_expression.type);
2666 ret = -EINVAL;
2667 goto error;
2668 }
2669
2670 alignment = right->u.unary_expression.u.
2671 unsigned_constant;
2672
2673 if (!is_align_valid(alignment)) {
2674 _BT_COMP_LOGE_NODE(right,
2675 "Invalid `align` attribute in floating point number field class: "
2676 "expecting power of two: "
2677 "align=%" PRIu64, alignment);
2678 ret = -EINVAL;
2679 goto error;
2680 }
2681
2682 _SET(&set, _FLOAT_ALIGN_SET);
2683 } else {
2684 _BT_COMP_LOGW_NODE(left,
2685 "Unknown attribute in floating point number field class: "
2686 "attr-name=\"%s\"",
2687 left->u.unary_expression.u.string);
2688 }
2689 }
2690
2691 if (!_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
2692 BT_COMP_LOGE_STR("Missing `mant_dig` attribute in floating point number field class.");
2693 ret = -EPERM;
2694 goto error;
2695 }
2696
2697 if (!_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
2698 BT_COMP_LOGE_STR("Missing `exp_dig` attribute in floating point number field class.");
2699 ret = -EPERM;
2700 goto error;
2701 }
2702
2703 if (mant_dig != 24 && mant_dig != 53) {
2704 BT_COMP_LOGE_STR("`mant_dig` attribute: expecting 24 or 53.");
2705 ret = -EPERM;
2706 goto error;
2707 }
2708
2709 if (mant_dig == 24 && exp_dig != 8) {
2710 BT_COMP_LOGE_STR("`exp_dig` attribute: expecting 8 because `mant_dig` is 24.");
2711 ret = -EPERM;
2712 goto error;
2713 }
2714
2715 if (mant_dig == 53 && exp_dig != 11) {
2716 BT_COMP_LOGE_STR("`exp_dig` attribute: expecting 11 because `mant_dig` is 53.");
2717 ret = -EPERM;
2718 goto error;
2719 }
2720
2721 if (!_IS_SET(&set, _INTEGER_ALIGN_SET)) {
2722 if ((mant_dig + exp_dig) % CHAR_BIT) {
2723 /* Bit-packed alignment */
2724 alignment = 1;
2725 } else {
2726 /* Byte-packed alignment */
2727 alignment = CHAR_BIT;
2728 }
2729 }
2730
2731 *float_decl = ctf_field_class_float_create();
2732 BT_ASSERT(*float_decl);
2733 (*float_decl)->base.base.alignment = alignment;
2734 (*float_decl)->base.byte_order = byte_order;
2735 (*float_decl)->base.size = mant_dig + exp_dig;
2736 return 0;
2737
2738 error:
2739 ctf_field_class_destroy((void *) *float_decl);
2740 *float_decl = NULL;
2741 return ret;
2742 }
2743
2744 static
2745 int visit_string_decl(struct ctx *ctx,
2746 struct bt_list_head *expressions,
2747 struct ctf_field_class_string **string_decl)
2748 {
2749 int set = 0;
2750 int ret = 0;
2751 struct ctf_node *expression;
2752 enum ctf_encoding encoding = CTF_ENCODING_UTF8;
2753
2754 *string_decl = NULL;
2755
2756 bt_list_for_each_entry(expression, expressions, siblings) {
2757 struct ctf_node *left, *right;
2758
2759 left = _BT_LIST_FIRST_ENTRY(&expression->u.ctf_expression.left,
2760 struct ctf_node, siblings);
2761 right = _BT_LIST_FIRST_ENTRY(
2762 &expression->u.ctf_expression.right, struct ctf_node,
2763 siblings);
2764
2765 if (left->u.unary_expression.type != UNARY_STRING) {
2766 _BT_COMP_LOGE_NODE(left,
2767 "Unexpected unary expression type: type=%d",
2768 left->u.unary_expression.type);
2769 ret = -EINVAL;
2770 goto error;
2771 }
2772
2773 if (strcmp(left->u.unary_expression.u.string, "encoding") == 0) {
2774 char *s_right;
2775
2776 if (_IS_SET(&set, _STRING_ENCODING_SET)) {
2777 _BT_COMP_LOGE_DUP_ATTR(left, "encoding",
2778 "string field class");
2779 ret = -EPERM;
2780 goto error;
2781 }
2782
2783 if (right->u.unary_expression.type != UNARY_STRING) {
2784 _BT_COMP_LOGE_NODE(right,
2785 "Invalid `encoding` attribute in string field class: "
2786 "expecting unary string.");
2787 ret = -EINVAL;
2788 goto error;
2789 }
2790
2791 s_right = ctf_ast_concatenate_unary_strings(
2792 &expression->u.ctf_expression.right);
2793 if (!s_right) {
2794 _BT_COMP_LOGE_NODE(right,
2795 "Unexpected unary expression for string field class's `encoding` attribute.");
2796 ret = -EINVAL;
2797 goto error;
2798 }
2799
2800 if (strcmp(s_right, "UTF8") == 0 ||
2801 strcmp(s_right, "utf8") == 0 ||
2802 strcmp(s_right, "utf-8") == 0 ||
2803 strcmp(s_right, "UTF-8") == 0 ||
2804 strcmp(s_right, "ASCII") == 0 ||
2805 strcmp(s_right, "ascii") == 0) {
2806 encoding = CTF_ENCODING_UTF8;
2807 } else if (strcmp(s_right, "none") == 0) {
2808 encoding = CTF_ENCODING_NONE;
2809 } else {
2810 _BT_COMP_LOGE_NODE(right,
2811 "Invalid `encoding` attribute in string field class: "
2812 "unknown encoding: encoding=\"%s\"",
2813 s_right);
2814 g_free(s_right);
2815 ret = -EINVAL;
2816 goto error;
2817 }
2818
2819 g_free(s_right);
2820 _SET(&set, _STRING_ENCODING_SET);
2821 } else {
2822 _BT_COMP_LOGW_NODE(left,
2823 "Unknown attribute in string field class: "
2824 "attr-name=\"%s\"",
2825 left->u.unary_expression.u.string);
2826 }
2827 }
2828
2829 *string_decl = ctf_field_class_string_create();
2830 BT_ASSERT(*string_decl);
2831 (*string_decl)->encoding = encoding;
2832 return 0;
2833
2834 error:
2835 ctf_field_class_destroy((void *) *string_decl);
2836 *string_decl = NULL;
2837 return ret;
2838 }
2839
2840 static
2841 int visit_field_class_specifier_list(struct ctx *ctx,
2842 struct ctf_node *ts_list, struct ctf_field_class **decl)
2843 {
2844 int ret = 0;
2845 struct ctf_node *first, *node;
2846
2847 *decl = NULL;
2848
2849 if (ts_list->type != NODE_TYPE_SPECIFIER_LIST) {
2850 _BT_COMP_LOGE_NODE(ts_list,
2851 "Unexpected node type: node-type=%d", ts_list->type);
2852 ret = -EINVAL;
2853 goto error;
2854 }
2855
2856 first = _BT_LIST_FIRST_ENTRY(&ts_list->u.field_class_specifier_list.head,
2857 struct ctf_node, siblings);
2858 if (first->type != NODE_TYPE_SPECIFIER) {
2859 _BT_COMP_LOGE_NODE(first,
2860 "Unexpected node type: node-type=%d", first->type);
2861 ret = -EINVAL;
2862 goto error;
2863 }
2864
2865 node = first->u.field_class_specifier.node;
2866
2867 switch (first->u.field_class_specifier.type) {
2868 case TYPESPEC_INTEGER:
2869 ret = visit_integer_decl(ctx, &node->u.integer.expressions,
2870 (void *) decl);
2871 if (ret) {
2872 BT_ASSERT(!*decl);
2873 goto error;
2874 }
2875 break;
2876 case TYPESPEC_FLOATING_POINT:
2877 ret = visit_floating_point_number_decl(ctx,
2878 &node->u.floating_point.expressions, (void *) decl);
2879 if (ret) {
2880 BT_ASSERT(!*decl);
2881 goto error;
2882 }
2883 break;
2884 case TYPESPEC_STRING:
2885 ret = visit_string_decl(ctx,
2886 &node->u.string.expressions, (void *) decl);
2887 if (ret) {
2888 BT_ASSERT(!*decl);
2889 goto error;
2890 }
2891 break;
2892 case TYPESPEC_STRUCT:
2893 ret = visit_struct_decl(ctx, node->u._struct.name,
2894 &node->u._struct.declaration_list,
2895 node->u._struct.has_body,
2896 &node->u._struct.min_align, (void *) decl);
2897 if (ret) {
2898 BT_ASSERT(!*decl);
2899 goto error;
2900 }
2901 break;
2902 case TYPESPEC_VARIANT:
2903 ret = visit_variant_decl(ctx, node->u.variant.name,
2904 node->u.variant.choice,
2905 &node->u.variant.declaration_list,
2906 node->u.variant.has_body, (void *) decl);
2907 if (ret) {
2908 BT_ASSERT(!*decl);
2909 goto error;
2910 }
2911 break;
2912 case TYPESPEC_ENUM:
2913 ret = visit_enum_decl(ctx, node->u._enum.enum_id,
2914 node->u._enum.container_field_class,
2915 &node->u._enum.enumerator_list,
2916 node->u._enum.has_body, (void *) decl);
2917 if (ret) {
2918 BT_ASSERT(!*decl);
2919 goto error;
2920 }
2921 break;
2922 case TYPESPEC_VOID:
2923 case TYPESPEC_CHAR:
2924 case TYPESPEC_SHORT:
2925 case TYPESPEC_INT:
2926 case TYPESPEC_LONG:
2927 case TYPESPEC_FLOAT:
2928 case TYPESPEC_DOUBLE:
2929 case TYPESPEC_SIGNED:
2930 case TYPESPEC_UNSIGNED:
2931 case TYPESPEC_BOOL:
2932 case TYPESPEC_COMPLEX:
2933 case TYPESPEC_IMAGINARY:
2934 case TYPESPEC_CONST:
2935 case TYPESPEC_ID_TYPE:
2936 ret = visit_field_class_specifier(ctx, ts_list, decl);
2937 if (ret) {
2938 _BT_COMP_LOGE_NODE(first,
2939 "Cannot visit field class specifier: ret=%d",
2940 ret);
2941 BT_ASSERT(!*decl);
2942 goto error;
2943 }
2944 break;
2945 default:
2946 _BT_COMP_LOGE_NODE(first,
2947 "Unexpected field class specifier type: node-type=%d",
2948 first->u.field_class_specifier.type);
2949 ret = -EINVAL;
2950 goto error;
2951 }
2952
2953 BT_ASSERT(*decl);
2954 return 0;
2955
2956 error:
2957 ctf_field_class_destroy((void *) *decl);
2958 *decl = NULL;
2959 return ret;
2960 }
2961
2962 static
2963 int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
2964 struct ctf_event_class *event_class, uint64_t *stream_id,
2965 int *set)
2966 {
2967 int ret = 0;
2968 char *left = NULL;
2969
2970 switch (node->type) {
2971 case NODE_TYPEDEF:
2972 ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
2973 &node->u.field_class_def.field_class_declarators);
2974 if (ret) {
2975 _BT_COMP_LOGE_NODE(node,
2976 "Cannot add field class found in event class.");
2977 goto error;
2978 }
2979 break;
2980 case NODE_TYPEALIAS:
2981 ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
2982 node->u.field_class_alias.alias);
2983 if (ret) {
2984 _BT_COMP_LOGE_NODE(node,
2985 "Cannot add field class alias found in event class.");
2986 goto error;
2987 }
2988 break;
2989 case NODE_CTF_EXPRESSION:
2990 {
2991 left = ctf_ast_concatenate_unary_strings(&node->u.ctf_expression.left);
2992 if (!left) {
2993 _BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
2994 ret = -EINVAL;
2995 goto error;
2996 }
2997
2998 if (strcmp(left, "name") == 0) {
2999 /* This is already known at this stage */
3000 if (_IS_SET(set, _EVENT_NAME_SET)) {
3001 _BT_COMP_LOGE_DUP_ATTR(node, "name", "event class");
3002 ret = -EPERM;
3003 goto error;
3004 }
3005
3006 _SET(set, _EVENT_NAME_SET);
3007 } else if (strcmp(left, "id") == 0) {
3008 int64_t id = -1;
3009
3010 if (_IS_SET(set, _EVENT_ID_SET)) {
3011 _BT_COMP_LOGE_DUP_ATTR(node, "id", "event class");
3012 ret = -EPERM;
3013 goto error;
3014 }
3015
3016 ret = get_unary_unsigned(ctx,
3017 &node->u.ctf_expression.right,
3018 (uint64_t *) &id);
3019 /* Only read "id" if get_unary_unsigned() succeeded. */
3020 if (ret || (!ret && id < 0)) {
3021 _BT_COMP_LOGE_NODE(node,
3022 "Unexpected unary expression for event class's `id` attribute.");
3023 ret = -EINVAL;
3024 goto error;
3025 }
3026
3027 event_class->id = id;
3028 _SET(set, _EVENT_ID_SET);
3029 } else if (strcmp(left, "stream_id") == 0) {
3030 if (_IS_SET(set, _EVENT_STREAM_ID_SET)) {
3031 _BT_COMP_LOGE_DUP_ATTR(node, "stream_id",
3032 "event class");
3033 ret = -EPERM;
3034 goto error;
3035 }
3036
3037 ret = get_unary_unsigned(ctx,
3038 &node->u.ctf_expression.right, stream_id);
3039
3040 /*
3041 * Only read "stream_id" if get_unary_unsigned()
3042 * succeeded.
3043 */
3044 if (ret) {
3045 _BT_COMP_LOGE_NODE(node,
3046 "Unexpected unary expression for event class's `stream_id` attribute.");
3047 ret = -EINVAL;
3048 goto error;
3049 }
3050
3051 _SET(set, _EVENT_STREAM_ID_SET);
3052 } else if (strcmp(left, "context") == 0) {
3053 if (_IS_SET(set, _EVENT_CONTEXT_SET)) {
3054 _BT_COMP_LOGE_NODE(node,
3055 "Duplicate `context` entry in event class.");
3056 ret = -EPERM;
3057 goto error;
3058 }
3059
3060 ret = visit_field_class_specifier_list(ctx,
3061 _BT_LIST_FIRST_ENTRY(
3062 &node->u.ctf_expression.right,
3063 struct ctf_node, siblings),
3064 &event_class->spec_context_fc);
3065 if (ret) {
3066 _BT_COMP_LOGE_NODE(node,
3067 "Cannot create event class's context field class.");
3068 goto error;
3069 }
3070
3071 BT_ASSERT(event_class->spec_context_fc);
3072 _SET(set, _EVENT_CONTEXT_SET);
3073 } else if (strcmp(left, "fields") == 0) {
3074 if (_IS_SET(set, _EVENT_FIELDS_SET)) {
3075 _BT_COMP_LOGE_NODE(node,
3076 "Duplicate `fields` entry in event class.");
3077 ret = -EPERM;
3078 goto error;
3079 }
3080
3081 ret = visit_field_class_specifier_list(ctx,
3082 _BT_LIST_FIRST_ENTRY(
3083 &node->u.ctf_expression.right,
3084 struct ctf_node, siblings),
3085 &event_class->payload_fc);
3086 if (ret) {
3087 _BT_COMP_LOGE_NODE(node,
3088 "Cannot create event class's payload field class.");
3089 goto error;
3090 }
3091
3092 BT_ASSERT(event_class->payload_fc);
3093 _SET(set, _EVENT_FIELDS_SET);
3094 } else if (strcmp(left, "loglevel") == 0) {
3095 uint64_t loglevel_value;
3096 bool is_log_level_known = true;
3097 bt_event_class_log_level log_level = -1;
3098
3099 if (_IS_SET(set, _EVENT_LOG_LEVEL_SET)) {
3100 _BT_COMP_LOGE_DUP_ATTR(node, "loglevel",
3101 "event class");
3102 ret = -EPERM;
3103 goto error;
3104 }
3105
3106 ret = get_unary_unsigned(ctx,
3107 &node->u.ctf_expression.right, &loglevel_value);
3108 if (ret) {
3109 _BT_COMP_LOGE_NODE(node,
3110 "Unexpected unary expression for event class's `loglevel` attribute.");
3111 ret = -EINVAL;
3112 goto error;
3113 }
3114
3115 switch (loglevel_value) {
3116 case 0:
3117 log_level = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY;
3118 break;
3119 case 1:
3120 log_level = BT_EVENT_CLASS_LOG_LEVEL_ALERT;
3121 break;
3122 case 2:
3123 log_level = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL;
3124 break;
3125 case 3:
3126 log_level = BT_EVENT_CLASS_LOG_LEVEL_ERROR;
3127 break;
3128 case 4:
3129 log_level = BT_EVENT_CLASS_LOG_LEVEL_WARNING;
3130 break;
3131 case 5:
3132 log_level = BT_EVENT_CLASS_LOG_LEVEL_NOTICE;
3133 break;
3134 case 6:
3135 log_level = BT_EVENT_CLASS_LOG_LEVEL_INFO;
3136 break;
3137 case 7:
3138 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM;
3139 break;
3140 case 8:
3141 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM;
3142 break;
3143 case 9:
3144 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS;
3145 break;
3146 case 10:
3147 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE;
3148 break;
3149 case 11:
3150 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT;
3151 break;
3152 case 12:
3153 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION;
3154 break;
3155 case 13:
3156 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE;
3157 break;
3158 case 14:
3159 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG;
3160 break;
3161 default:
3162 is_log_level_known = false;
3163 _BT_COMP_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
3164 "log-level=%" PRIu64, loglevel_value);
3165 }
3166
3167 if (is_log_level_known) {
3168 ctf_event_class_set_log_level(event_class, log_level);
3169 }
3170
3171 _SET(set, _EVENT_LOG_LEVEL_SET);
3172 } else if (strcmp(left, "model.emf.uri") == 0) {
3173 char *right;
3174
3175 if (_IS_SET(set, _EVENT_MODEL_EMF_URI_SET)) {
3176 _BT_COMP_LOGE_DUP_ATTR(node, "model.emf.uri",
3177 "event class");
3178 ret = -EPERM;
3179 goto error;
3180 }
3181
3182 right = ctf_ast_concatenate_unary_strings(
3183 &node->u.ctf_expression.right);
3184 if (!right) {
3185 _BT_COMP_LOGE_NODE(node,
3186 "Unexpected unary expression for event class's `model.emf.uri` attribute.");
3187 ret = -EINVAL;
3188 goto error;
3189 }
3190
3191 if (strlen(right) == 0) {
3192 _BT_COMP_LOGW_NODE(node,
3193 "Not setting event class's EMF URI because it's empty.");
3194 } else {
3195 g_string_assign(event_class->emf_uri,
3196 right);
3197 }
3198
3199 g_free(right);
3200 _SET(set, _EVENT_MODEL_EMF_URI_SET);
3201 } else {
3202 _BT_COMP_LOGW_NODE(node,
3203 "Unknown attribute in event class: "
3204 "attr-name=\"%s\"", left);
3205 }
3206
3207 g_free(left);
3208 left = NULL;
3209 break;
3210 }
3211 default:
3212 ret = -EPERM;
3213 goto error;
3214 }
3215
3216 goto end;
3217
3218 error:
3219 g_free(left);
3220
3221 end:
3222 return ret;
3223 }
3224
3225 static
3226 char *get_event_decl_name(struct ctx *ctx, struct ctf_node *node)
3227 {
3228 char *left = NULL;
3229 char *name = NULL;
3230 struct ctf_node *iter;
3231 struct bt_list_head *decl_list = &node->u.event.declaration_list;
3232
3233 bt_list_for_each_entry(iter, decl_list, siblings) {
3234 if (iter->type != NODE_CTF_EXPRESSION) {
3235 continue;
3236 }
3237
3238 left = ctf_ast_concatenate_unary_strings(&iter->u.ctf_expression.left);
3239 if (!left) {
3240 _BT_COMP_LOGE_NODE(iter,
3241 "Cannot concatenate unary strings.");
3242 goto error;
3243 }
3244
3245 if (strcmp(left, "name") == 0) {
3246 name = ctf_ast_concatenate_unary_strings(
3247 &iter->u.ctf_expression.right);
3248 if (!name) {
3249 _BT_COMP_LOGE_NODE(iter,
3250 "Unexpected unary expression for event class's `name` attribute.");
3251 goto error;
3252 }
3253 }
3254
3255 g_free(left);
3256 left = NULL;
3257
3258 if (name) {
3259 break;
3260 }
3261 }
3262
3263 return name;
3264
3265 error:
3266 g_free(left);
3267 return NULL;
3268 }
3269
3270 static
3271 int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
3272 {
3273 int ret = 0;
3274 int set = 0;
3275 struct ctf_node *iter;
3276 uint64_t stream_id = 0;
3277 char *event_name = NULL;
3278 struct ctf_event_class *event_class = NULL;
3279 struct ctf_stream_class *stream_class = NULL;
3280 struct bt_list_head *decl_list = &node->u.event.declaration_list;
3281 bool pop_scope = false;
3282
3283 if (node->visited) {
3284 goto end;
3285 }
3286
3287 node->visited = TRUE;
3288 event_name = get_event_decl_name(ctx, node);
3289 if (!event_name) {
3290 _BT_COMP_LOGE_NODE(node,
3291 "Missing `name` attribute in event class.");
3292 ret = -EPERM;
3293 goto error;
3294 }
3295
3296 event_class = ctf_event_class_create();
3297 BT_ASSERT(event_class);
3298 g_string_assign(event_class->name, event_name);
3299 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
3300 pop_scope = true;
3301
3302 bt_list_for_each_entry(iter, decl_list, siblings) {
3303 ret = visit_event_decl_entry(ctx, iter, event_class,
3304 &stream_id, &set);
3305 if (ret) {
3306 _BT_COMP_LOGE_NODE(iter, "Cannot visit event class's entry: "
3307 "ret=%d", ret);
3308 goto error;
3309 }
3310 }
3311
3312 if (!_IS_SET(&set, _EVENT_STREAM_ID_SET)) {
3313 /*
3314 * Allow missing stream_id if there is only a single
3315 * stream class.
3316 */
3317 switch (ctx->ctf_tc->stream_classes->len) {
3318 case 0:
3319 /* Create implicit stream class if there's none */
3320 stream_id = 0;
3321 stream_class = ctf_stream_class_create();
3322 BT_ASSERT(stream_class);
3323 stream_class->id = stream_id;
3324 g_ptr_array_add(ctx->ctf_tc->stream_classes,
3325 stream_class);
3326 break;
3327 case 1:
3328 /* Single stream class: get its ID */
3329 stream_class = ctx->ctf_tc->stream_classes->pdata[0];
3330 stream_id = stream_class->id;
3331 break;
3332 default:
3333 _BT_COMP_LOGE_NODE(node,
3334 "Missing `stream_id` attribute in event class.");
3335 ret = -EPERM;
3336 goto error;
3337 }
3338 }
3339
3340 /* We have the stream ID now; get the stream class if found */
3341 if (!stream_class) {
3342 stream_class = ctf_trace_class_borrow_stream_class_by_id(
3343 ctx->ctf_tc, stream_id);
3344 if (!stream_class) {
3345 _BT_COMP_LOGE_NODE(node,
3346 "Cannot find stream class at this point: "
3347 "id=%" PRId64, stream_id);
3348 ret = -EINVAL;
3349 goto error;
3350 }
3351 }
3352
3353 BT_ASSERT(stream_class);
3354
3355 if (!_IS_SET(&set, _EVENT_ID_SET)) {
3356 /* Allow only one event without ID per stream */
3357 if (stream_class->event_classes->len != 0) {
3358 _BT_COMP_LOGE_NODE(node,
3359 "Missing `id` attribute in event class.");
3360 ret = -EPERM;
3361 goto error;
3362 }
3363
3364 /* Automatic ID */
3365 event_class->id = 0;
3366 }
3367
3368 if (ctf_stream_class_borrow_event_class_by_id(stream_class,
3369 event_class->id)) {
3370 _BT_COMP_LOGE_NODE(node,
3371 "Duplicate event class (same ID) in the same stream class: "
3372 "id=%" PRId64, event_class->id);
3373 ret = -EEXIST;
3374 goto error;
3375 }
3376
3377 ctf_stream_class_append_event_class(stream_class, event_class);
3378 event_class = NULL;
3379 goto end;
3380
3381 error:
3382 ctf_event_class_destroy(event_class);
3383 event_class = NULL;
3384
3385 if (ret >= 0) {
3386 ret = -1;
3387 }
3388
3389 end:
3390 if (pop_scope) {
3391 ctx_pop_scope(ctx);
3392 }
3393
3394 g_free(event_name);
3395
3396 return ret;
3397 }
3398
3399 static
3400 int auto_map_field_to_trace_clock_class(struct ctx *ctx,
3401 struct ctf_field_class *fc)
3402 {
3403 struct ctf_clock_class *clock_class_to_map_to = NULL;
3404 struct ctf_field_class_int *int_fc = (void *) fc;
3405 int ret = 0;
3406 uint64_t clock_class_count;
3407
3408 if (!fc) {
3409 goto end;
3410 }
3411
3412 if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
3413 fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
3414 goto end;
3415 }
3416
3417 if (int_fc->mapped_clock_class) {
3418 /* Already mapped */
3419 goto end;
3420 }
3421
3422 clock_class_count = ctx->ctf_tc->clock_classes->len;
3423
3424 switch (clock_class_count) {
3425 case 0:
3426 /*
3427 * No clock class exists in the trace at this point. Create an
3428 * implicit one at 1 GHz, named `default`, and use this clock
3429 * class.
3430 */
3431 clock_class_to_map_to = ctf_clock_class_create();
3432 BT_ASSERT(clock_class_to_map_to);
3433 clock_class_to_map_to->frequency = UINT64_C(1000000000);
3434 g_string_assign(clock_class_to_map_to->name, "default");
3435 BT_ASSERT(ret == 0);
3436 g_ptr_array_add(ctx->ctf_tc->clock_classes,
3437 clock_class_to_map_to);
3438 break;
3439 case 1:
3440 /*
3441 * Only one clock class exists in the trace at this point: use
3442 * this one.
3443 */
3444 clock_class_to_map_to = ctx->ctf_tc->clock_classes->pdata[0];
3445 break;
3446 default:
3447 /*
3448 * Timestamp field not mapped to a clock class and there's more
3449 * than one clock class in the trace: this is an error.
3450 */
3451 BT_COMP_LOGE_STR("Timestamp field found with no mapped clock class, "
3452 "but there's more than one clock class in the trace at this point.");
3453 ret = -1;
3454 goto end;
3455 }
3456
3457 BT_ASSERT(clock_class_to_map_to);
3458 int_fc->mapped_clock_class = clock_class_to_map_to;
3459
3460 end:
3461 return ret;
3462 }
3463
3464 static
3465 int auto_map_fields_to_trace_clock_class(struct ctx *ctx,
3466 struct ctf_field_class *root_fc, const char *field_name)
3467 {
3468 int ret = 0;
3469 uint64_t i, count;
3470 struct ctf_field_class_struct *struct_fc = (void *) root_fc;
3471 struct ctf_field_class_variant *var_fc = (void *) root_fc;
3472
3473 if (!root_fc) {
3474 goto end;
3475 }
3476
3477 if (root_fc->type != CTF_FIELD_CLASS_TYPE_STRUCT &&
3478 root_fc->type != CTF_FIELD_CLASS_TYPE_VARIANT) {
3479 goto end;
3480 }
3481
3482 if (root_fc->type == CTF_FIELD_CLASS_TYPE_STRUCT) {
3483 count = struct_fc->members->len;
3484 } else {
3485 count = var_fc->options->len;
3486 }
3487
3488 for (i = 0; i < count; i++) {
3489 struct ctf_named_field_class *named_fc = NULL;
3490
3491 if (root_fc->type == CTF_FIELD_CLASS_TYPE_STRUCT) {
3492 named_fc = ctf_field_class_struct_borrow_member_by_index(
3493 struct_fc, i);
3494 } else if (root_fc->type == CTF_FIELD_CLASS_TYPE_VARIANT) {
3495 named_fc = ctf_field_class_variant_borrow_option_by_index(
3496 var_fc, i);
3497 } else {
3498 bt_common_abort();
3499 }
3500
3501 if (strcmp(named_fc->name->str, field_name) == 0) {
3502 ret = auto_map_field_to_trace_clock_class(ctx,
3503 named_fc->fc);
3504 if (ret) {
3505 BT_COMP_LOGE("Cannot automatically map field to trace's clock class: "
3506 "field-name=\"%s\"", field_name);
3507 goto end;
3508 }
3509 }
3510
3511 ret = auto_map_fields_to_trace_clock_class(ctx, named_fc->fc,
3512 field_name);
3513 if (ret) {
3514 BT_COMP_LOGE("Cannot automatically map structure or variant field class's fields to trace's clock class: "
3515 "field-name=\"%s\", root-field-name=\"%s\"",
3516 field_name, named_fc->name->str);
3517 goto end;
3518 }
3519 }
3520
3521 end:
3522 return ret;
3523 }
3524
3525 static
3526 int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
3527 struct ctf_stream_class *stream_class, int *set)
3528 {
3529 int ret = 0;
3530 char *left = NULL;
3531
3532 switch (node->type) {
3533 case NODE_TYPEDEF:
3534 ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
3535 &node->u.field_class_def.field_class_declarators);
3536 if (ret) {
3537 _BT_COMP_LOGE_NODE(node,
3538 "Cannot add field class found in stream class.");
3539 goto error;
3540 }
3541 break;
3542 case NODE_TYPEALIAS:
3543 ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
3544 node->u.field_class_alias.alias);
3545 if (ret) {
3546 _BT_COMP_LOGE_NODE(node,
3547 "Cannot add field class alias found in stream class.");
3548 goto error;
3549 }
3550 break;
3551 case NODE_CTF_EXPRESSION:
3552 {
3553 left = ctf_ast_concatenate_unary_strings(&node->u.ctf_expression.left);
3554 if (!left) {
3555 _BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
3556 ret = -EINVAL;
3557 goto error;
3558 }
3559
3560 if (strcmp(left, "id") == 0) {
3561 int64_t id;
3562
3563 if (_IS_SET(set, _STREAM_ID_SET)) {
3564 _BT_COMP_LOGE_DUP_ATTR(node, "id",
3565 "stream declaration");
3566 ret = -EPERM;
3567 goto error;
3568 }
3569
3570 ret = get_unary_unsigned(ctx,
3571 &node->u.ctf_expression.right,
3572 (uint64_t *) &id);
3573
3574 /* Only read "id" if get_unary_unsigned() succeeded. */
3575 if (ret || (!ret && id < 0)) {
3576 _BT_COMP_LOGE_NODE(node,
3577 "Unexpected unary expression for stream class's `id` attribute.");
3578 ret = -EINVAL;
3579 goto error;
3580 }
3581
3582 if (ctf_trace_class_borrow_stream_class_by_id(
3583 ctx->ctf_tc, id)) {
3584 _BT_COMP_LOGE_NODE(node,
3585 "Duplicate stream class (same ID): id=%" PRId64,
3586 id);
3587 ret = -EEXIST;
3588 goto error;
3589 }
3590
3591 stream_class->id = id;
3592 _SET(set, _STREAM_ID_SET);
3593 } else if (strcmp(left, "event.header") == 0) {
3594 if (_IS_SET(set, _STREAM_EVENT_HEADER_SET)) {
3595 _BT_COMP_LOGE_NODE(node,
3596 "Duplicate `event.header` entry in stream class.");
3597 ret = -EPERM;
3598 goto error;
3599 }
3600
3601 ret = visit_field_class_specifier_list(ctx,
3602 _BT_LIST_FIRST_ENTRY(
3603 &node->u.ctf_expression.right,
3604 struct ctf_node, siblings),
3605 &stream_class->event_header_fc);
3606 if (ret) {
3607 _BT_COMP_LOGE_NODE(node,
3608 "Cannot create stream class's event header field class.");
3609 goto error;
3610 }
3611
3612 BT_ASSERT(stream_class->event_header_fc);
3613 ret = auto_map_fields_to_trace_clock_class(ctx,
3614 stream_class->event_header_fc, "timestamp");
3615 if (ret) {
3616 _BT_COMP_LOGE_NODE(node,
3617 "Cannot automatically map specific event header field class fields named `timestamp` to trace's clock class.");
3618 goto error;
3619 }
3620
3621 _SET(set, _STREAM_EVENT_HEADER_SET);
3622 } else if (strcmp(left, "event.context") == 0) {
3623 if (_IS_SET(set, _STREAM_EVENT_CONTEXT_SET)) {
3624 _BT_COMP_LOGE_NODE(node,
3625 "Duplicate `event.context` entry in stream class.");
3626 ret = -EPERM;
3627 goto error;
3628 }
3629
3630 ret = visit_field_class_specifier_list(ctx,
3631 _BT_LIST_FIRST_ENTRY(
3632 &node->u.ctf_expression.right,
3633 struct ctf_node, siblings),
3634 &stream_class->event_common_context_fc);
3635 if (ret) {
3636 _BT_COMP_LOGE_NODE(node,
3637 "Cannot create stream class's event context field class.");
3638 goto error;
3639 }
3640
3641 BT_ASSERT(stream_class->event_common_context_fc);
3642 _SET(set, _STREAM_EVENT_CONTEXT_SET);
3643 } else if (strcmp(left, "packet.context") == 0) {
3644 if (_IS_SET(set, _STREAM_PACKET_CONTEXT_SET)) {
3645 _BT_COMP_LOGE_NODE(node,
3646 "Duplicate `packet.context` entry in stream class.");
3647 ret = -EPERM;
3648 goto error;
3649 }
3650
3651 ret = visit_field_class_specifier_list(ctx,
3652 _BT_LIST_FIRST_ENTRY(
3653 &node->u.ctf_expression.right,
3654 struct ctf_node, siblings),
3655 &stream_class->packet_context_fc);
3656 if (ret) {
3657 _BT_COMP_LOGE_NODE(node,
3658 "Cannot create stream class's packet context field class.");
3659 goto error;
3660 }
3661
3662 BT_ASSERT(stream_class->packet_context_fc);
3663 ret = auto_map_fields_to_trace_clock_class(ctx,
3664 stream_class->packet_context_fc,
3665 "timestamp_begin");
3666 if (ret) {
3667 _BT_COMP_LOGE_NODE(node,
3668 "Cannot automatically map specific packet context field class fields named `timestamp_begin` to trace's clock class.");
3669 goto error;
3670 }
3671
3672 ret = auto_map_fields_to_trace_clock_class(ctx,
3673 stream_class->packet_context_fc,
3674 "timestamp_end");
3675 if (ret) {
3676 _BT_COMP_LOGE_NODE(node,
3677 "Cannot automatically map specific packet context field class fields named `timestamp_end` to trace's clock class.");
3678 goto error;
3679 }
3680
3681 _SET(set, _STREAM_PACKET_CONTEXT_SET);
3682 } else {
3683 _BT_COMP_LOGW_NODE(node,
3684 "Unknown attribute in stream class: "
3685 "attr-name=\"%s\"", left);
3686 }
3687
3688 g_free(left);
3689 left = NULL;
3690 break;
3691 }
3692
3693 default:
3694 ret = -EPERM;
3695 goto error;
3696 }
3697
3698 return 0;
3699
3700 error:
3701 g_free(left);
3702 return ret;
3703 }
3704
3705 static
3706 int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
3707 {
3708 int set = 0;
3709 int ret = 0;
3710 struct ctf_node *iter;
3711 struct ctf_stream_class *stream_class = NULL;
3712 struct bt_list_head *decl_list = &node->u.stream.declaration_list;
3713
3714 if (node->visited) {
3715 goto end;
3716 }
3717
3718 node->visited = TRUE;
3719 stream_class = ctf_stream_class_create();
3720 BT_ASSERT(stream_class);
3721 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
3722
3723 bt_list_for_each_entry(iter, decl_list, siblings) {
3724 ret = visit_stream_decl_entry(ctx, iter, stream_class, &set);
3725 if (ret) {
3726 _BT_COMP_LOGE_NODE(iter,
3727 "Cannot visit stream class's entry: "
3728 "ret=%d", ret);
3729 ctx_pop_scope(ctx);
3730 goto error;
3731 }
3732 }
3733
3734 ctx_pop_scope(ctx);
3735
3736 if (_IS_SET(&set, _STREAM_ID_SET)) {
3737 /* Check that packet header has `stream_id` field */
3738 struct ctf_named_field_class *named_fc = NULL;
3739
3740 if (!ctx->ctf_tc->packet_header_fc) {
3741 _BT_COMP_LOGE_NODE(node,
3742 "Stream class has a `id` attribute, "
3743 "but trace has no packet header field class.");
3744 goto error;
3745 }
3746
3747 named_fc = ctf_field_class_struct_borrow_member_by_name(
3748 (void *) ctx->ctf_tc->packet_header_fc, "stream_id");
3749 if (!named_fc) {
3750 _BT_COMP_LOGE_NODE(node,
3751 "Stream class has a `id` attribute, "
3752 "but trace's packet header field class has no `stream_id` field.");
3753 goto error;
3754 }
3755
3756 if (named_fc->fc->type != CTF_FIELD_CLASS_TYPE_INT &&
3757 named_fc->fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
3758 _BT_COMP_LOGE_NODE(node,
3759 "Stream class has a `id` attribute, "
3760 "but trace's packet header field class's `stream_id` field is not an integer field class.");
3761 goto error;
3762 }
3763 } else {
3764 /* Allow only _one_ ID-less stream */
3765 if (ctx->ctf_tc->stream_classes->len != 0) {
3766 _BT_COMP_LOGE_NODE(node,
3767 "Missing `id` attribute in stream class as there's more than one stream class in the trace.");
3768 ret = -EPERM;
3769 goto error;
3770 }
3771
3772 /* Automatic ID: 0 */
3773 stream_class->id = 0;
3774 }
3775
3776 /*
3777 * Make sure that this stream class's ID is currently unique in
3778 * the trace.
3779 */
3780 if (ctf_trace_class_borrow_stream_class_by_id(ctx->ctf_tc,
3781 stream_class->id)) {
3782 _BT_COMP_LOGE_NODE(node,
3783 "Duplicate stream class (same ID): id=%" PRId64,
3784 stream_class->id);
3785 ret = -EINVAL;
3786 goto error;
3787 }
3788
3789 g_ptr_array_add(ctx->ctf_tc->stream_classes, stream_class);
3790 stream_class = NULL;
3791 goto end;
3792
3793 error:
3794 ctf_stream_class_destroy(stream_class);
3795 stream_class = NULL;
3796
3797 end:
3798 return ret;
3799 }
3800
3801 static
3802 int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
3803 {
3804 int ret = 0;
3805 char *left = NULL;
3806 uint64_t val;
3807
3808 switch (node->type) {
3809 case NODE_TYPEDEF:
3810 ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
3811 &node->u.field_class_def.field_class_declarators);
3812 if (ret) {
3813 _BT_COMP_LOGE_NODE(node,
3814 "Cannot add field class found in trace (`trace` block).");
3815 goto error;
3816 }
3817 break;
3818 case NODE_TYPEALIAS:
3819 ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
3820 node->u.field_class_alias.alias);
3821 if (ret) {
3822 _BT_COMP_LOGE_NODE(node,
3823 "Cannot add field class alias found in trace (`trace` block).");
3824 goto error;
3825 }
3826 break;
3827 case NODE_CTF_EXPRESSION:
3828 {
3829 left = ctf_ast_concatenate_unary_strings(&node->u.ctf_expression.left);
3830 if (!left) {
3831 _BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
3832 ret = -EINVAL;
3833 goto error;
3834 }
3835
3836 if (strcmp(left, "major") == 0) {
3837 if (_IS_SET(set, _TRACE_MAJOR_SET)) {
3838 _BT_COMP_LOGE_DUP_ATTR(node, "major", "trace");
3839 ret = -EPERM;
3840 goto error;
3841 }
3842
3843 ret = get_unary_unsigned(ctx,
3844 &node->u.ctf_expression.right, &val);
3845 if (ret) {
3846 _BT_COMP_LOGE_NODE(node,
3847 "Unexpected unary expression for trace's `major` attribute.");
3848 ret = -EINVAL;
3849 goto error;
3850 }
3851
3852 if (val != 1) {
3853 _BT_COMP_LOGE_NODE(node,
3854 "Invalid trace's `minor` attribute: expecting 1.");
3855 goto error;
3856 }
3857
3858 ctx->ctf_tc->major = val;
3859 _SET(set, _TRACE_MAJOR_SET);
3860 } else if (strcmp(left, "minor") == 0) {
3861 if (_IS_SET(set, _TRACE_MINOR_SET)) {
3862 _BT_COMP_LOGE_DUP_ATTR(node, "minor", "trace");
3863 ret = -EPERM;
3864 goto error;
3865 }
3866
3867 ret = get_unary_unsigned(ctx,
3868 &node->u.ctf_expression.right, &val);
3869 if (ret) {
3870 _BT_COMP_LOGE_NODE(node,
3871 "Unexpected unary expression for trace's `minor` attribute.");
3872 ret = -EINVAL;
3873 goto error;
3874 }
3875
3876 if (val != 8) {
3877 _BT_COMP_LOGE_NODE(node,
3878 "Invalid trace's `minor` attribute: expecting 8.");
3879 goto error;
3880 }
3881
3882 ctx->ctf_tc->minor = val;
3883 _SET(set, _TRACE_MINOR_SET);
3884 } else if (strcmp(left, "uuid") == 0) {
3885 if (_IS_SET(set, _TRACE_UUID_SET)) {
3886 _BT_COMP_LOGE_DUP_ATTR(node, "uuid", "trace");
3887 ret = -EPERM;
3888 goto error;
3889 }
3890
3891 ret = get_unary_uuid(ctx,
3892 &node->u.ctf_expression.right,
3893 ctx->ctf_tc->uuid);
3894 if (ret) {
3895 _BT_COMP_LOGE_NODE(node,
3896 "Invalid trace's `uuid` attribute.");
3897 goto error;
3898 }
3899
3900 ctx->ctf_tc->is_uuid_set = true;
3901 _SET(set, _TRACE_UUID_SET);
3902 } else if (strcmp(left, "byte_order") == 0) {
3903 /* Default byte order is already known at this stage */
3904 if (_IS_SET(set, _TRACE_BYTE_ORDER_SET)) {
3905 _BT_COMP_LOGE_DUP_ATTR(node, "byte_order",
3906 "trace");
3907 ret = -EPERM;
3908 goto error;
3909 }
3910
3911 BT_ASSERT(ctx->ctf_tc->default_byte_order != CTF_BYTE_ORDER_UNKNOWN);
3912 _SET(set, _TRACE_BYTE_ORDER_SET);
3913 } else if (strcmp(left, "packet.header") == 0) {
3914 if (_IS_SET(set, _TRACE_PACKET_HEADER_SET)) {
3915 _BT_COMP_LOGE_NODE(node,
3916 "Duplicate `packet.header` entry in trace.");
3917 ret = -EPERM;
3918 goto error;
3919 }
3920
3921 ret = visit_field_class_specifier_list(ctx,
3922 _BT_LIST_FIRST_ENTRY(
3923 &node->u.ctf_expression.right,
3924 struct ctf_node, siblings),
3925 &ctx->ctf_tc->packet_header_fc);
3926 if (ret) {
3927 _BT_COMP_LOGE_NODE(node,
3928 "Cannot create trace's packet header field class.");
3929 goto error;
3930 }
3931
3932 BT_ASSERT(ctx->ctf_tc->packet_header_fc);
3933 _SET(set, _TRACE_PACKET_HEADER_SET);
3934 } else {
3935 _BT_COMP_LOGW_NODE(node,
3936 "Unknown attribute in stream class: "
3937 "attr-name=\"%s\"", left);
3938 }
3939
3940 g_free(left);
3941 left = NULL;
3942 break;
3943 }
3944 default:
3945 _BT_COMP_LOGE_NODE(node, "Unknown expression in trace.");
3946 ret = -EINVAL;
3947 goto error;
3948 }
3949
3950 return 0;
3951
3952 error:
3953 g_free(left);
3954 return ret;
3955 }
3956
3957 static
3958 int visit_trace_decl(struct ctx *ctx, struct ctf_node *node)
3959 {
3960 int ret = 0;
3961 int set = 0;
3962 struct ctf_node *iter;
3963 struct bt_list_head *decl_list = &node->u.trace.declaration_list;
3964
3965 if (node->visited) {
3966 goto end;
3967 }
3968
3969 node->visited = TRUE;
3970
3971 if (ctx->is_trace_visited) {
3972 _BT_COMP_LOGE_NODE(node, "Duplicate trace (`trace` block).");
3973 ret = -EEXIST;
3974 goto error;
3975 }
3976
3977 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
3978
3979 bt_list_for_each_entry(iter, decl_list, siblings) {
3980 ret = visit_trace_decl_entry(ctx, iter, &set);
3981 if (ret) {
3982 _BT_COMP_LOGE_NODE(iter, "Cannot visit trace's entry (`trace` block): "
3983 "ret=%d", ret);
3984 ctx_pop_scope(ctx);
3985 goto error;
3986 }
3987 }
3988
3989 ctx_pop_scope(ctx);
3990
3991 if (!_IS_SET(&set, _TRACE_MAJOR_SET)) {
3992 _BT_COMP_LOGE_NODE(node,
3993 "Missing `major` attribute in trace (`trace` block).");
3994 ret = -EPERM;
3995 goto error;
3996 }
3997
3998 if (!_IS_SET(&set, _TRACE_MINOR_SET)) {
3999 _BT_COMP_LOGE_NODE(node,
4000 "Missing `minor` attribute in trace (`trace` block).");
4001 ret = -EPERM;
4002 goto error;
4003 }
4004
4005 if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
4006 _BT_COMP_LOGE_NODE(node,
4007 "Missing `byte_order` attribute in trace (`trace` block).");
4008 ret = -EPERM;
4009 goto error;
4010 }
4011
4012 ctx->is_trace_visited = true;
4013
4014 end:
4015 return 0;
4016
4017 error:
4018 return ret;
4019 }
4020
4021 static
4022 int visit_env(struct ctx *ctx, struct ctf_node *node)
4023 {
4024 int ret = 0;
4025 char *left = NULL;
4026 struct ctf_node *entry_node;
4027 struct bt_list_head *decl_list = &node->u.env.declaration_list;
4028
4029 if (node->visited) {
4030 goto end;
4031 }
4032
4033 node->visited = TRUE;
4034
4035 bt_list_for_each_entry(entry_node, decl_list, siblings) {
4036 struct bt_list_head *right_head =
4037 &entry_node->u.ctf_expression.right;
4038
4039 if (entry_node->type != NODE_CTF_EXPRESSION) {
4040 _BT_COMP_LOGE_NODE(entry_node,
4041 "Wrong expression in environment entry: "
4042 "node-type=%d", entry_node->type);
4043 ret = -EPERM;
4044 goto error;
4045 }
4046
4047 left = ctf_ast_concatenate_unary_strings(
4048 &entry_node->u.ctf_expression.left);
4049 if (!left) {
4050 _BT_COMP_LOGE_NODE(entry_node,
4051 "Cannot get environment entry's name.");
4052 ret = -EINVAL;
4053 goto error;
4054 }
4055
4056 if (is_unary_string(right_head)) {
4057 char *right = ctf_ast_concatenate_unary_strings(right_head);
4058
4059 if (!right) {
4060 _BT_COMP_LOGE_NODE(entry_node,
4061 "Unexpected unary expression for environment entry's value: "
4062 "name=\"%s\"", left);
4063 ret = -EINVAL;
4064 goto error;
4065 }
4066
4067 if (strcmp(left, "tracer_name") == 0) {
4068 if (strncmp(right, "lttng", 5) == 0) {
4069 BT_COMP_LOGI("Detected LTTng trace from `%s` environment value: "
4070 "tracer-name=\"%s\"",
4071 left, right);
4072 ctx->is_lttng = true;
4073 }
4074 }
4075
4076 ctf_trace_class_append_env_entry(ctx->ctf_tc,
4077 left, CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR,
4078 right, 0);
4079 g_free(right);
4080 } else if (is_unary_unsigned(right_head) ||
4081 is_unary_signed(right_head)) {
4082 int64_t v;
4083
4084 if (is_unary_unsigned(right_head)) {
4085 ret = get_unary_unsigned(ctx, right_head,
4086 (uint64_t *) &v);
4087 } else {
4088 ret = get_unary_signed(right_head, &v);
4089 }
4090 if (ret) {
4091 _BT_COMP_LOGE_NODE(entry_node,
4092 "Unexpected unary expression for environment entry's value: "
4093 "name=\"%s\"", left);
4094 ret = -EINVAL;
4095 goto error;
4096 }
4097
4098 ctf_trace_class_append_env_entry(ctx->ctf_tc,
4099 left, CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT,
4100 NULL, v);
4101 } else {
4102 _BT_COMP_LOGW_NODE(entry_node,
4103 "Environment entry has unknown type: "
4104 "name=\"%s\"", left);
4105 }
4106
4107 g_free(left);
4108 left = NULL;
4109 }
4110
4111 end:
4112 return 0;
4113
4114 error:
4115 g_free(left);
4116 return ret;
4117 }
4118
4119 static
4120 int set_trace_byte_order(struct ctx *ctx, struct ctf_node *trace_node)
4121 {
4122 int ret = 0;
4123 int set = 0;
4124 char *left = NULL;
4125 struct ctf_node *node;
4126 struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
4127
4128 bt_list_for_each_entry(node, decl_list, siblings) {
4129 if (node->type == NODE_CTF_EXPRESSION) {
4130 struct ctf_node *right_node;
4131
4132 left = ctf_ast_concatenate_unary_strings(
4133 &node->u.ctf_expression.left);
4134 if (!left) {
4135 _BT_COMP_LOGE_NODE(node,
4136 "Cannot concatenate unary strings.");
4137 ret = -EINVAL;
4138 goto error;
4139 }
4140
4141 if (strcmp(left, "byte_order") == 0) {
4142 enum ctf_byte_order bo;
4143
4144 if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
4145 _BT_COMP_LOGE_DUP_ATTR(node, "byte_order",
4146 "trace");
4147 ret = -EPERM;
4148 goto error;
4149 }
4150
4151 _SET(&set, _TRACE_BYTE_ORDER_SET);
4152 right_node = _BT_LIST_FIRST_ENTRY(
4153 &node->u.ctf_expression.right,
4154 struct ctf_node, siblings);
4155 bo = byte_order_from_unary_expr(ctx,
4156 right_node);
4157 if (bo == CTF_BYTE_ORDER_UNKNOWN) {
4158 _BT_COMP_LOGE_NODE(node,
4159 "Invalid `byte_order` attribute in trace (`trace` block): "
4160 "expecting `le`, `be`, or `network`.");
4161 ret = -EINVAL;
4162 goto error;
4163 } else if (bo == CTF_BYTE_ORDER_DEFAULT) {
4164 _BT_COMP_LOGE_NODE(node,
4165 "Invalid `byte_order` attribute in trace (`trace` block): "
4166 "cannot be set to `native` here.");
4167 ret = -EPERM;
4168 goto error;
4169 }
4170
4171 ctx->ctf_tc->default_byte_order = bo;
4172 }
4173
4174 g_free(left);
4175 left = NULL;
4176 }
4177 }
4178
4179 if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
4180 _BT_COMP_LOGE_NODE(trace_node,
4181 "Missing `byte_order` attribute in trace (`trace` block).");
4182 ret = -EINVAL;
4183 goto error;
4184 }
4185
4186 return 0;
4187
4188 error:
4189 g_free(left);
4190 return ret;
4191 }
4192
4193 static
4194 int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
4195 struct ctf_clock_class *clock, int *set, int64_t *offset_seconds,
4196 uint64_t *offset_cycles)
4197 {
4198 int ret = 0;
4199 char *left = NULL;
4200
4201 if (entry_node->type != NODE_CTF_EXPRESSION) {
4202 _BT_COMP_LOGE_NODE(entry_node,
4203 "Unexpected node type: node-type=%d",
4204 entry_node->type);
4205 ret = -EPERM;
4206 goto error;
4207 }
4208
4209 left = ctf_ast_concatenate_unary_strings(&entry_node->u.ctf_expression.left);
4210 if (!left) {
4211 _BT_COMP_LOGE_NODE(entry_node, "Cannot concatenate unary strings.");
4212 ret = -EINVAL;
4213 goto error;
4214 }
4215
4216 if (strcmp(left, "name") == 0) {
4217 char *right;
4218
4219 if (_IS_SET(set, _CLOCK_NAME_SET)) {
4220 _BT_COMP_LOGE_DUP_ATTR(entry_node, "name", "clock class");
4221 ret = -EPERM;
4222 goto error;
4223 }
4224
4225 right = ctf_ast_concatenate_unary_strings(
4226 &entry_node->u.ctf_expression.right);
4227 if (!right) {
4228 _BT_COMP_LOGE_NODE(entry_node,
4229 "Unexpected unary expression for clock class's `name` attribute.");
4230 ret = -EINVAL;
4231 goto error;
4232 }
4233
4234 g_string_assign(clock->name, right);
4235 g_free(right);
4236 _SET(set, _CLOCK_NAME_SET);
4237 } else if (strcmp(left, "uuid") == 0) {
4238 bt_uuid_t uuid;
4239
4240 if (_IS_SET(set, _CLOCK_UUID_SET)) {
4241 _BT_COMP_LOGE_DUP_ATTR(entry_node, "uuid", "clock class");
4242 ret = -EPERM;
4243 goto error;
4244 }
4245
4246 ret = get_unary_uuid(ctx, &entry_node->u.ctf_expression.right,
4247 uuid);
4248 if (ret) {
4249 _BT_COMP_LOGE_NODE(entry_node,
4250 "Invalid clock class's `uuid` attribute.");
4251 goto error;
4252 }
4253
4254 clock->has_uuid = true;
4255 bt_uuid_copy(clock->uuid, uuid);
4256 _SET(set, _CLOCK_UUID_SET);
4257 } else if (strcmp(left, "description") == 0) {
4258 char *right;
4259
4260 if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
4261 _BT_COMP_LOGE_DUP_ATTR(entry_node, "description",
4262 "clock class");
4263 ret = -EPERM;
4264 goto error;
4265 }
4266
4267 right = ctf_ast_concatenate_unary_strings(
4268 &entry_node->u.ctf_expression.right);
4269 if (!right) {
4270 _BT_COMP_LOGE_NODE(entry_node,
4271 "Unexpected unary expression for clock class's `description` attribute.");
4272 ret = -EINVAL;
4273 goto error;
4274 }
4275
4276 g_string_assign(clock->description, right);
4277 g_free(right);
4278 _SET(set, _CLOCK_DESCRIPTION_SET);
4279 } else if (strcmp(left, "freq") == 0) {
4280 uint64_t freq = UINT64_C(-1);
4281
4282 if (_IS_SET(set, _CLOCK_FREQ_SET)) {
4283 _BT_COMP_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
4284 ret = -EPERM;
4285 goto error;
4286 }
4287
4288 ret = get_unary_unsigned(ctx,
4289 &entry_node->u.ctf_expression.right, &freq);
4290 if (ret) {
4291 _BT_COMP_LOGE_NODE(entry_node,
4292 "Unexpected unary expression for clock class's `freq` attribute.");
4293 ret = -EINVAL;
4294 goto error;
4295 }
4296
4297 if (freq == UINT64_C(-1) || freq == 0) {
4298 _BT_COMP_LOGE_NODE(entry_node,
4299 "Invalid clock class frequency: freq=%" PRIu64,
4300 freq);
4301 ret = -EINVAL;
4302 goto error;
4303 }
4304
4305 clock->frequency = freq;
4306 _SET(set, _CLOCK_FREQ_SET);
4307 } else if (strcmp(left, "precision") == 0) {
4308 uint64_t precision;
4309
4310 if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
4311 _BT_COMP_LOGE_DUP_ATTR(entry_node, "precision",
4312 "clock class");
4313 ret = -EPERM;
4314 goto error;
4315 }
4316
4317 ret = get_unary_unsigned(ctx,
4318 &entry_node->u.ctf_expression.right, &precision);
4319 if (ret) {
4320 _BT_COMP_LOGE_NODE(entry_node,
4321 "Unexpected unary expression for clock class's `precision` attribute.");
4322 ret = -EINVAL;
4323 goto error;
4324 }
4325
4326 clock->precision = precision;
4327 _SET(set, _CLOCK_PRECISION_SET);
4328 } else if (strcmp(left, "offset_s") == 0) {
4329 if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
4330 _BT_COMP_LOGE_DUP_ATTR(entry_node, "offset_s",
4331 "clock class");
4332 ret = -EPERM;
4333 goto error;
4334 }
4335
4336 ret = get_unary_signed(
4337 &entry_node->u.ctf_expression.right, offset_seconds);
4338 if (ret) {
4339 _BT_COMP_LOGE_NODE(entry_node,
4340 "Unexpected unary expression for clock class's `offset_s` attribute.");
4341 ret = -EINVAL;
4342 goto error;
4343 }
4344
4345 _SET(set, _CLOCK_OFFSET_S_SET);
4346 } else if (strcmp(left, "offset") == 0) {
4347 if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
4348 _BT_COMP_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
4349 ret = -EPERM;
4350 goto error;
4351 }
4352
4353 ret = get_unary_unsigned(ctx,
4354 &entry_node->u.ctf_expression.right, offset_cycles);
4355 if (ret) {
4356 _BT_COMP_LOGE_NODE(entry_node,
4357 "Unexpected unary expression for clock class's `offset` attribute.");
4358 ret = -EINVAL;
4359 goto error;
4360 }
4361
4362 _SET(set, _CLOCK_OFFSET_SET);
4363 } else if (strcmp(left, "absolute") == 0) {
4364 struct ctf_node *right;
4365
4366 if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
4367 _BT_COMP_LOGE_DUP_ATTR(entry_node, "absolute",
4368 "clock class");
4369 ret = -EPERM;
4370 goto error;
4371 }
4372
4373 right = _BT_LIST_FIRST_ENTRY(
4374 &entry_node->u.ctf_expression.right,
4375 struct ctf_node, siblings);
4376 ret = get_boolean(ctx, right);
4377 if (ret < 0) {
4378 _BT_COMP_LOGE_NODE(entry_node,
4379 "Unexpected unary expression for clock class's `absolute` attribute.");
4380 ret = -EINVAL;
4381 goto error;
4382 }
4383
4384 clock->is_absolute = ret;
4385 _SET(set, _CLOCK_ABSOLUTE_SET);
4386 } else {
4387 _BT_COMP_LOGW_NODE(entry_node,
4388 "Unknown attribute in clock class: attr-name=\"%s\"",
4389 left);
4390 }
4391
4392 g_free(left);
4393 left = NULL;
4394 return 0;
4395
4396 error:
4397 g_free(left);
4398 return ret;
4399 }
4400
4401 static inline
4402 uint64_t cycles_from_ns(uint64_t frequency, uint64_t ns)
4403 {
4404 uint64_t cycles;
4405
4406 /* 1GHz */
4407 if (frequency == UINT64_C(1000000000)) {
4408 cycles = ns;
4409 } else {
4410 cycles = (uint64_t) (((double) ns * (double) frequency) / 1e9);
4411 }
4412
4413 return cycles;
4414 }
4415
4416 static
4417 void calibrate_clock_class_offsets(int64_t *offset_seconds,
4418 uint64_t *offset_cycles, uint64_t freq)
4419 {
4420 if (*offset_cycles >= freq) {
4421 const uint64_t s_in_offset_cycles = *offset_cycles / freq;
4422
4423 *offset_seconds += (int64_t) s_in_offset_cycles;
4424 *offset_cycles -= (s_in_offset_cycles * freq);
4425 }
4426 }
4427
4428 static
4429 void apply_clock_class_is_absolute(struct ctx *ctx,
4430 struct ctf_clock_class *clock)
4431 {
4432 if (ctx->decoder_config.force_clock_class_origin_unix_epoch) {
4433 clock->is_absolute = true;
4434 }
4435
4436 return;
4437 }
4438
4439 static
4440 void apply_clock_class_offset(struct ctx *ctx,
4441 struct ctf_clock_class *clock)
4442 {
4443 uint64_t freq;
4444 int64_t offset_s_to_apply = ctx->decoder_config.clock_class_offset_s;
4445 uint64_t offset_ns_to_apply;
4446 int64_t cur_offset_s;
4447 uint64_t cur_offset_cycles;
4448
4449 if (ctx->decoder_config.clock_class_offset_s == 0 &&
4450 ctx->decoder_config.clock_class_offset_ns == 0) {
4451 goto end;
4452 }
4453
4454 /* Transfer nanoseconds to seconds as much as possible */
4455 if (ctx->decoder_config.clock_class_offset_ns < 0) {
4456 const int64_t abs_ns = -ctx->decoder_config.clock_class_offset_ns;
4457 const int64_t abs_extra_s = abs_ns / INT64_C(1000000000) + 1;
4458 const int64_t extra_s = -abs_extra_s;
4459 const int64_t offset_ns = ctx->decoder_config.clock_class_offset_ns -
4460 (extra_s * INT64_C(1000000000));
4461
4462 BT_ASSERT(offset_ns > 0);
4463 offset_ns_to_apply = (uint64_t) offset_ns;
4464 offset_s_to_apply += extra_s;
4465 } else {
4466 const int64_t extra_s = ctx->decoder_config.clock_class_offset_ns /
4467 INT64_C(1000000000);
4468 const int64_t offset_ns = ctx->decoder_config.clock_class_offset_ns -
4469 (extra_s * INT64_C(1000000000));
4470
4471 BT_ASSERT(offset_ns >= 0);
4472 offset_ns_to_apply = (uint64_t) offset_ns;
4473 offset_s_to_apply += extra_s;
4474 }
4475
4476 freq = clock->frequency;
4477 cur_offset_s = clock->offset_seconds;
4478 cur_offset_cycles = clock->offset_cycles;
4479
4480 /* Apply offsets */
4481 cur_offset_s += offset_s_to_apply;
4482 cur_offset_cycles += cycles_from_ns(freq, offset_ns_to_apply);
4483
4484 /*
4485 * Recalibrate offsets because the part in cycles can be greater
4486 * than the frequency at this point.
4487 */
4488 calibrate_clock_class_offsets(&cur_offset_s, &cur_offset_cycles, freq);
4489
4490 /* Set final offsets */
4491 clock->offset_seconds = cur_offset_s;
4492 clock->offset_cycles = cur_offset_cycles;
4493
4494 end:
4495 return;
4496 }
4497
4498 static
4499 int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node)
4500 {
4501 int ret = 0;
4502 int set = 0;
4503 struct ctf_clock_class *clock;
4504 struct ctf_node *entry_node;
4505 struct bt_list_head *decl_list = &clock_node->u.clock.declaration_list;
4506 const char *clock_class_name;
4507 int64_t offset_seconds = 0;
4508 uint64_t offset_cycles = 0;
4509 uint64_t freq;
4510
4511 if (clock_node->visited) {
4512 return 0;
4513 }
4514
4515 clock_node->visited = TRUE;
4516
4517 /* CTF 1.8's default frequency for a clock class is 1 GHz */
4518 clock = ctf_clock_class_create();
4519 if (!clock) {
4520 _BT_COMP_LOGE_NODE(clock_node,
4521 "Cannot create default clock class.");
4522 ret = -ENOMEM;
4523 goto end;
4524 }
4525
4526 bt_list_for_each_entry(entry_node, decl_list, siblings) {
4527 ret = visit_clock_decl_entry(ctx, entry_node, clock, &set,
4528 &offset_seconds, &offset_cycles);
4529 if (ret) {
4530 _BT_COMP_LOGE_NODE(entry_node,
4531 "Cannot visit clock class's entry: ret=%d",
4532 ret);
4533 goto end;
4534 }
4535 }
4536
4537 if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
4538 _BT_COMP_LOGE_NODE(clock_node,
4539 "Missing `name` attribute in clock class.");
4540 ret = -EPERM;
4541 goto end;
4542 }
4543
4544 clock_class_name = clock->name->str;
4545 BT_ASSERT(clock_class_name);
4546 if (ctx->is_lttng && strcmp(clock_class_name, "monotonic") == 0) {
4547 /*
4548 * Old versions of LTTng forgot to set its clock class
4549 * as absolute, even if it is. This is important because
4550 * it's a condition to be able to sort messages
4551 * from different sources.
4552 */
4553 clock->is_absolute = true;
4554 }
4555
4556 /*
4557 * Adjust offsets so that the part in cycles is less than the
4558 * frequency (move to the part in seconds).
4559 */
4560 freq = clock->frequency;
4561 calibrate_clock_class_offsets(&offset_seconds, &offset_cycles, freq);
4562 BT_ASSERT(offset_cycles < clock->frequency);
4563 clock->offset_seconds = offset_seconds;
4564 clock->offset_cycles = offset_cycles;
4565 apply_clock_class_offset(ctx, clock);
4566 apply_clock_class_is_absolute(ctx, clock);
4567 g_ptr_array_add(ctx->ctf_tc->clock_classes, clock);
4568 clock = NULL;
4569
4570 end:
4571 if (clock) {
4572 ctf_clock_class_destroy(clock);
4573 }
4574
4575 return ret;
4576 }
4577
4578 static
4579 int visit_root_decl(struct ctx *ctx, struct ctf_node *root_decl_node)
4580 {
4581 int ret = 0;
4582
4583 if (root_decl_node->visited) {
4584 goto end;
4585 }
4586
4587 root_decl_node->visited = TRUE;
4588
4589 switch (root_decl_node->type) {
4590 case NODE_TYPEDEF:
4591 ret = visit_field_class_def(ctx,
4592 root_decl_node->u.field_class_def.field_class_specifier_list,
4593 &root_decl_node->u.field_class_def.field_class_declarators);
4594 if (ret) {
4595 _BT_COMP_LOGE_NODE(root_decl_node,
4596 "Cannot add field class found in root scope.");
4597 goto end;
4598 }
4599 break;
4600 case NODE_TYPEALIAS:
4601 ret = visit_field_class_alias(ctx, root_decl_node->u.field_class_alias.target,
4602 root_decl_node->u.field_class_alias.alias);
4603 if (ret) {
4604 _BT_COMP_LOGE_NODE(root_decl_node,
4605 "Cannot add field class alias found in root scope.");
4606 goto end;
4607 }
4608 break;
4609 case NODE_TYPE_SPECIFIER_LIST:
4610 {
4611 struct ctf_field_class *decl = NULL;
4612
4613 /*
4614 * Just add the field class specifier to the root
4615 * declaration scope. Put local reference.
4616 */
4617 ret = visit_field_class_specifier_list(ctx, root_decl_node, &decl);
4618 if (ret) {
4619 _BT_COMP_LOGE_NODE(root_decl_node,
4620 "Cannot visit root scope's field class: "
4621 "ret=%d", ret);
4622 BT_ASSERT(!decl);
4623 goto end;
4624 }
4625
4626 ctf_field_class_destroy(decl);
4627 decl = NULL;
4628 break;
4629 }
4630 default:
4631 _BT_COMP_LOGE_NODE(root_decl_node,
4632 "Unexpected node type: node-type=%d",
4633 root_decl_node->type);
4634 ret = -EPERM;
4635 goto end;
4636 }
4637
4638 end:
4639 return ret;
4640 }
4641
4642 BT_HIDDEN
4643 struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
4644 const struct ctf_metadata_decoder_config *decoder_config)
4645 {
4646 struct ctx *ctx = NULL;
4647
4648 /* Create visitor's context */
4649 ctx = ctx_create(decoder_config);
4650 if (!ctx) {
4651 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
4652 decoder_config->self_comp,
4653 "Cannot create visitor's context.");
4654 goto error;
4655 }
4656
4657 goto end;
4658
4659 error:
4660 ctx_destroy(ctx);
4661 ctx = NULL;
4662
4663 end:
4664 return (void *) ctx;
4665 }
4666
4667 BT_HIDDEN
4668 void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor)
4669 {
4670 ctx_destroy((void *) visitor);
4671 }
4672
4673 BT_HIDDEN
4674 bt_trace_class *ctf_visitor_generate_ir_get_ir_trace_class(
4675 struct ctf_visitor_generate_ir *visitor)
4676 {
4677 struct ctx *ctx = (void *) visitor;
4678
4679 BT_ASSERT_DBG(ctx);
4680
4681 if (ctx->trace_class) {
4682 bt_trace_class_get_ref(ctx->trace_class);
4683 }
4684
4685 return ctx->trace_class;
4686 }
4687
4688 BT_HIDDEN
4689 struct ctf_trace_class *ctf_visitor_generate_ir_borrow_ctf_trace_class(
4690 struct ctf_visitor_generate_ir *visitor)
4691 {
4692 struct ctx *ctx = (void *) visitor;
4693
4694 BT_ASSERT_DBG(ctx);
4695 BT_ASSERT_DBG(ctx->ctf_tc);
4696 return ctx->ctf_tc;
4697 }
4698
4699 BT_HIDDEN
4700 int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
4701 struct ctf_node *node)
4702 {
4703 int ret = 0;
4704 struct ctx *ctx = (void *) visitor;
4705
4706 BT_COMP_LOGI_STR("Visiting metadata's AST to generate CTF IR objects.");
4707
4708 switch (node->type) {
4709 case NODE_ROOT:
4710 {
4711 struct ctf_node *iter;
4712 bool got_trace_decl = false;
4713
4714 /*
4715 * The first thing we need is the native byte order of
4716 * the trace block, because early class aliases can have
4717 * a `byte_order` attribute set to `native`. If we don't
4718 * have the native byte order yet, and we don't have any
4719 * trace block yet, then fail with EINCOMPLETE.
4720 */
4721 if (ctx->ctf_tc->default_byte_order == CTF_BYTE_ORDER_UNKNOWN) {
4722 bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
4723 if (got_trace_decl) {
4724 _BT_COMP_LOGE_NODE(node,
4725 "Duplicate trace (`trace` block).");
4726 ret = -1;
4727 goto end;
4728 }
4729
4730 ret = set_trace_byte_order(ctx, iter);
4731 if (ret) {
4732 _BT_COMP_LOGE_NODE(node,
4733 "Cannot set trace's native byte order: "
4734 "ret=%d", ret);
4735 goto end;
4736 }
4737
4738 got_trace_decl = true;
4739 }
4740
4741 if (!got_trace_decl) {
4742 BT_COMP_LOGD_STR("Incomplete AST: need trace (`trace` block).");
4743 ret = -EINCOMPLETE;
4744 goto end;
4745 }
4746 }
4747
4748 BT_ASSERT(ctx->ctf_tc->default_byte_order == CTF_BYTE_ORDER_LITTLE ||
4749 ctx->ctf_tc->default_byte_order == CTF_BYTE_ORDER_BIG);
4750 BT_ASSERT(ctx->current_scope &&
4751 !ctx->current_scope->parent_scope);
4752
4753 /* Environment */
4754 bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
4755 ret = visit_env(ctx, iter);
4756 if (ret) {
4757 _BT_COMP_LOGE_NODE(iter,
4758 "Cannot visit trace's environment (`env` block) entry: "
4759 "ret=%d", ret);
4760 goto end;
4761 }
4762 }
4763
4764 BT_ASSERT(ctx->current_scope &&
4765 !ctx->current_scope->parent_scope);
4766
4767 /*
4768 * Visit clock blocks.
4769 */
4770 bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
4771 ret = visit_clock_decl(ctx, iter);
4772 if (ret) {
4773 _BT_COMP_LOGE_NODE(iter,
4774 "Cannot visit clock class: ret=%d",
4775 ret);
4776 goto end;
4777 }
4778 }
4779
4780 BT_ASSERT(ctx->current_scope &&
4781 !ctx->current_scope->parent_scope);
4782
4783 /*
4784 * Visit root declarations next, as they can be used by any
4785 * following entity.
4786 */
4787 bt_list_for_each_entry(iter, &node->u.root.declaration_list,
4788 siblings) {
4789 ret = visit_root_decl(ctx, iter);
4790 if (ret) {
4791 _BT_COMP_LOGE_NODE(iter,
4792 "Cannot visit root entry: ret=%d",
4793 ret);
4794 goto end;
4795 }
4796 }
4797
4798 BT_ASSERT(ctx->current_scope &&
4799 !ctx->current_scope->parent_scope);
4800
4801 /* Callsite blocks are not supported */
4802 bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
4803 _BT_COMP_LOGW_NODE(iter,
4804 "\"callsite\" blocks are not supported as of this version.");
4805 }
4806
4807 BT_ASSERT(ctx->current_scope &&
4808 !ctx->current_scope->parent_scope);
4809
4810 /* Trace */
4811 bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
4812 ret = visit_trace_decl(ctx, iter);
4813 if (ret) {
4814 _BT_COMP_LOGE_NODE(iter,
4815 "Cannot visit trace (`trace` block): "
4816 "ret=%d", ret);
4817 goto end;
4818 }
4819 }
4820
4821 BT_ASSERT(ctx->current_scope &&
4822 !ctx->current_scope->parent_scope);
4823
4824 /* Streams */
4825 bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
4826 ret = visit_stream_decl(ctx, iter);
4827 if (ret) {
4828 _BT_COMP_LOGE_NODE(iter,
4829 "Cannot visit stream class: ret=%d",
4830 ret);
4831 goto end;
4832 }
4833 }
4834
4835 BT_ASSERT(ctx->current_scope &&
4836 !ctx->current_scope->parent_scope);
4837
4838 /* Events */
4839 bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
4840 ret = visit_event_decl(ctx, iter);
4841 if (ret) {
4842 _BT_COMP_LOGE_NODE(iter,
4843 "Cannot visit event class: ret=%d",
4844 ret);
4845 goto end;
4846 }
4847 }
4848
4849 BT_ASSERT(ctx->current_scope &&
4850 !ctx->current_scope->parent_scope);
4851 break;
4852 }
4853 default:
4854 _BT_COMP_LOGE_NODE(node,
4855 "Unexpected node type: node-type=%d",
4856 node->type);
4857 ret = -EINVAL;
4858 goto end;
4859 }
4860
4861 /* Update default clock classes */
4862 ret = ctf_trace_class_update_default_clock_classes(ctx->ctf_tc,
4863 &ctx->log_cfg);
4864 if (ret) {
4865 ret = -EINVAL;
4866 goto end;
4867 }
4868
4869 /* Update trace class meanings */
4870 ret = ctf_trace_class_update_meanings(ctx->ctf_tc);
4871 if (ret) {
4872 ret = -EINVAL;
4873 goto end;
4874 }
4875
4876 /* Update stream class configuration */
4877 ret = ctf_trace_class_update_stream_class_config(ctx->ctf_tc);
4878 if (ret) {
4879 ret = -EINVAL;
4880 goto end;
4881 }
4882
4883 /* Update text arrays and sequences */
4884 ret = ctf_trace_class_update_text_array_sequence(ctx->ctf_tc);
4885 if (ret) {
4886 ret = -EINVAL;
4887 goto end;
4888 }
4889
4890 /* Resolve sequence lengths and variant tags */
4891 ret = ctf_trace_class_resolve_field_classes(ctx->ctf_tc, &ctx->log_cfg);
4892 if (ret) {
4893 ret = -EINVAL;
4894 goto end;
4895 }
4896
4897 if (ctx->trace_class) {
4898 /*
4899 * Update "in IR" for field classes.
4900 *
4901 * If we have no IR trace class, then we'll have no way
4902 * to create IR fields anyway, so we leave all the
4903 * `in_ir` members false.
4904 */
4905 ret = ctf_trace_class_update_in_ir(ctx->ctf_tc);
4906 if (ret) {
4907 ret = -EINVAL;
4908 goto end;
4909 }
4910 }
4911
4912 /* Update saved value indexes */
4913 ret = ctf_trace_class_update_value_storing_indexes(ctx->ctf_tc);
4914 if (ret) {
4915 ret = -EINVAL;
4916 goto end;
4917 }
4918
4919 /* Validate what we have so far */
4920 ret = ctf_trace_class_validate(ctx->ctf_tc, &ctx->log_cfg);
4921 if (ret) {
4922 ret = -EINVAL;
4923 goto end;
4924 }
4925
4926 /*
4927 * If there are fields which are not related to the CTF format
4928 * itself in the packet header and in event header field
4929 * classes, warn about it because they are never translated.
4930 */
4931 ctf_trace_class_warn_meaningless_header_fields(ctx->ctf_tc,
4932 &ctx->log_cfg);
4933
4934 if (ctx->trace_class) {
4935 /* Copy new CTF metadata -> new IR metadata */
4936 ret = ctf_trace_class_translate(ctx->log_cfg.self_comp,
4937 ctx->trace_class, ctx->ctf_tc);
4938 if (ret) {
4939 ret = -EINVAL;
4940 goto end;
4941 }
4942 }
4943
4944 end:
4945 return ret;
4946 }
BabelTrace - Trace Format Babel Tower
This page took 0.213 seconds and 3 git commands to generate.