1 // SPDX-License-Identifier: MIT
3 * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
12 #include <side/trace.h>
15 void tracer_print_struct(const struct side_type_description
*type_desc
, const struct side_arg_vec_description
*sav_desc
);
17 void tracer_print_array(const struct side_type_description
*type_desc
, const struct side_arg_vec_description
*sav_desc
);
19 void tracer_print_vla(const struct side_type_description
*type_desc
, const struct side_arg_vec_description
*sav_desc
);
21 void tracer_print_vla_visitor(const struct side_type_description
*type_desc
, void *app_ctx
);
23 void tracer_print_array_fixint(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
);
25 void tracer_print_vla_fixint(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
);
27 void tracer_print_dynamic(const struct side_arg_dynamic_vec
*dynamic_item
);
29 void tracer_print_type(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
);
32 void tracer_print_attr_type(const char *separator
, const struct side_attr
*attr
)
34 printf("{ key%s \"%s\", value%s ", separator
, attr
->key
, separator
);
35 switch (attr
->value
.type
) {
36 case SIDE_ATTR_TYPE_BOOL
:
37 printf("%s", attr
->value
.u
.side_bool
? "true" : "false");
39 case SIDE_ATTR_TYPE_U8
:
40 printf("%" PRIu8
, attr
->value
.u
.side_u8
);
42 case SIDE_ATTR_TYPE_U16
:
43 printf("%" PRIu16
, attr
->value
.u
.side_u16
);
45 case SIDE_ATTR_TYPE_U32
:
46 printf("%" PRIu32
, attr
->value
.u
.side_u32
);
48 case SIDE_ATTR_TYPE_U64
:
49 printf("%" PRIu64
, attr
->value
.u
.side_u64
);
51 case SIDE_ATTR_TYPE_S8
:
52 printf("%" PRId8
, attr
->value
.u
.side_s8
);
54 case SIDE_ATTR_TYPE_S16
:
55 printf("%" PRId16
, attr
->value
.u
.side_s16
);
57 case SIDE_ATTR_TYPE_S32
:
58 printf("%" PRId32
, attr
->value
.u
.side_s32
);
60 case SIDE_ATTR_TYPE_S64
:
61 printf("%" PRId64
, attr
->value
.u
.side_s64
);
63 case SIDE_ATTR_TYPE_FLOAT_BINARY16
:
65 printf("%g", (double) attr
->value
.u
.side_float_binary16
);
68 fprintf(stderr
, "ERROR: Unsupported binary16 float type\n");
71 case SIDE_ATTR_TYPE_FLOAT_BINARY32
:
73 printf("%g", (double) attr
->value
.u
.side_float_binary32
);
76 fprintf(stderr
, "ERROR: Unsupported binary32 float type\n");
79 case SIDE_ATTR_TYPE_FLOAT_BINARY64
:
81 printf("%g", (double) attr
->value
.u
.side_float_binary64
);
84 fprintf(stderr
, "ERROR: Unsupported binary64 float type\n");
87 case SIDE_ATTR_TYPE_FLOAT_BINARY128
:
89 printf("%Lg", (long double) attr
->value
.u
.side_float_binary128
);
92 fprintf(stderr
, "ERROR: Unsupported binary128 float type\n");
95 case SIDE_ATTR_TYPE_STRING
:
96 printf("\"%s\"", attr
->value
.u
.string
);
99 fprintf(stderr
, "ERROR: <UNKNOWN ATTRIBUTE TYPE>");
106 void print_attributes(const char *prefix_str
, const char *separator
,
107 const struct side_attr
*attr
, uint32_t nr_attr
)
113 printf("%s%s [ ", prefix_str
, separator
);
114 for (i
= 0; i
< nr_attr
; i
++) {
115 printf("%s", i
? ", " : "");
116 tracer_print_attr_type(separator
, &attr
[i
]);
122 void print_enum(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
)
124 const struct side_enum_mappings
*mappings
= type_desc
->u
.side_enum
.mappings
;
125 int i
, print_count
= 0;
128 if (type_desc
->u
.side_enum
.elem_type
->type
!= item
->type
) {
129 fprintf(stderr
, "ERROR: Unexpected enum element type\n");
132 switch (item
->type
) {
134 value
= (int64_t) item
->u
.side_u8
;
137 value
= (int64_t) item
->u
.side_u16
;
140 value
= (int64_t) item
->u
.side_u32
;
143 value
= (int64_t) item
->u
.side_u64
;
146 value
= (int64_t) item
->u
.side_s8
;
149 value
= (int64_t) item
->u
.side_s16
;
152 value
= (int64_t) item
->u
.side_s32
;
155 value
= (int64_t) item
->u
.side_s64
;
158 fprintf(stderr
, "ERROR: Unexpected enum element type\n");
161 print_attributes("attr", ":", mappings
->attr
, mappings
->nr_attr
);
162 printf("%s", mappings
->nr_attr
? ", " : "");
163 tracer_print_type(type_desc
->u
.side_enum
.elem_type
, item
);
164 printf(", labels: [ ");
165 for (i
= 0; i
< mappings
->nr_mappings
; i
++) {
166 const struct side_enum_mapping
*mapping
= &mappings
->mappings
[i
];
168 if (mapping
->range_end
< mapping
->range_begin
) {
169 fprintf(stderr
, "ERROR: Unexpected enum range: %" PRIu64
"-%" PRIu64
"\n",
170 mapping
->range_begin
, mapping
->range_end
);
173 if (value
>= mapping
->range_begin
&& value
<= mapping
->range_end
) {
174 printf("%s", print_count
++ ? ", " : "");
175 printf("\"%s\"", mapping
->label
);
179 printf("<NO LABEL>");
184 uint32_t enum_elem_type_to_stride(const struct side_type_description
*elem_type
)
188 switch (elem_type
->type
) {
189 case SIDE_TYPE_U8
: /* Fall-through */
203 fprintf(stderr
, "ERROR: Unexpected enum element type\n");
210 void print_enum_bitmap(const struct side_type_description
*type_desc
,
211 const struct side_arg_vec
*item
)
213 const struct side_type_description
*elem_type
= type_desc
->u
.side_enum_bitmap
.elem_type
;
214 const struct side_enum_bitmap_mappings
*side_enum_mappings
= type_desc
->u
.side_enum_bitmap
.mappings
;
215 int i
, print_count
= 0;
216 uint32_t stride_bit
, nr_items
;
217 const struct side_arg_vec
*array_item
;
219 switch (elem_type
->type
) {
220 case SIDE_TYPE_U8
: /* Fall-through */
221 case SIDE_TYPE_BYTE
: /* Fall-through */
222 case SIDE_TYPE_U16
: /* Fall-through */
223 case SIDE_TYPE_U32
: /* Fall-through */
225 stride_bit
= enum_elem_type_to_stride(elem_type
);
229 case SIDE_TYPE_ARRAY
:
230 stride_bit
= enum_elem_type_to_stride(elem_type
->u
.side_array
.elem_type
);
231 array_item
= item
->u
.side_array
->sav
;
232 nr_items
= type_desc
->u
.side_array
.length
;
235 stride_bit
= enum_elem_type_to_stride(elem_type
->u
.side_vla
.elem_type
);
236 array_item
= item
->u
.side_vla
->sav
;
237 nr_items
= item
->u
.side_vla
->len
;
240 fprintf(stderr
, "ERROR: Unexpected enum element type\n");
244 print_attributes("attr", ":", side_enum_mappings
->attr
, side_enum_mappings
->nr_attr
);
245 printf("%s", side_enum_mappings
->nr_attr
? ", " : "");
246 printf("labels: [ ");
247 for (i
= 0; i
< side_enum_mappings
->nr_mappings
; i
++) {
248 const struct side_enum_bitmap_mapping
*mapping
= &side_enum_mappings
->mappings
[i
];
252 if (mapping
->range_begin
< 0 || mapping
->range_end
< mapping
->range_begin
) {
253 fprintf(stderr
, "ERROR: Unexpected enum bitmap range: %" PRIu64
"-%" PRIu64
"\n",
254 mapping
->range_begin
, mapping
->range_end
);
257 for (bit
= mapping
->range_begin
; bit
<= mapping
->range_end
; bit
++) {
258 if (bit
> (nr_items
* stride_bit
) - 1)
260 switch (stride_bit
) {
263 uint8_t v
= array_item
[bit
/ 8].u
.side_u8
;
264 if (v
& (1ULL << (bit
% 8))) {
272 uint16_t v
= array_item
[bit
/ 16].u
.side_u16
;
273 if (v
& (1ULL << (bit
% 16))) {
281 uint32_t v
= array_item
[bit
/ 32].u
.side_u32
;
282 if (v
& (1ULL << (bit
% 32))) {
290 uint64_t v
= array_item
[bit
/ 64].u
.side_u64
;
291 if (v
& (1ULL << (bit
% 64))) {
303 printf("%s", print_count
++ ? ", " : "");
304 printf("\"%s\"", mapping
->label
);
308 printf("<NO LABEL>");
313 void tracer_print_basic_type_header(const struct side_type_description
*type_desc
)
315 print_attributes("attr", ":", type_desc
->u
.side_basic
.attr
, type_desc
->u
.side_basic
.nr_attr
);
316 printf("%s", type_desc
->u
.side_basic
.nr_attr
? ", " : "");
321 void tracer_print_type(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
)
325 switch (type_desc
->type
) {
326 case SIDE_TYPE_ARRAY
:
327 switch (item
->type
) {
328 case SIDE_TYPE_ARRAY_U8
:
329 case SIDE_TYPE_ARRAY_U16
:
330 case SIDE_TYPE_ARRAY_U32
:
331 case SIDE_TYPE_ARRAY_U64
:
332 case SIDE_TYPE_ARRAY_S8
:
333 case SIDE_TYPE_ARRAY_S16
:
334 case SIDE_TYPE_ARRAY_S32
:
335 case SIDE_TYPE_ARRAY_S64
:
336 case SIDE_TYPE_ARRAY_BYTE
:
337 case SIDE_TYPE_ARRAY
:
340 fprintf(stderr
, "ERROR: type mismatch between description and arguments\n");
347 switch (item
->type
) {
348 case SIDE_TYPE_VLA_U8
:
349 case SIDE_TYPE_VLA_U16
:
350 case SIDE_TYPE_VLA_U32
:
351 case SIDE_TYPE_VLA_U64
:
352 case SIDE_TYPE_VLA_S8
:
353 case SIDE_TYPE_VLA_S16
:
354 case SIDE_TYPE_VLA_S32
:
355 case SIDE_TYPE_VLA_S64
:
356 case SIDE_TYPE_VLA_BYTE
:
360 fprintf(stderr
, "ERROR: type mismatch between description and arguments\n");
367 switch (item
->type
) {
378 fprintf(stderr
, "ERROR: type mismatch between description and arguments\n");
384 case SIDE_TYPE_ENUM_BITMAP
:
385 switch (item
->type
) {
391 case SIDE_TYPE_ARRAY
:
395 fprintf(stderr
, "ERROR: type mismatch between description and arguments\n");
402 if (type_desc
->type
!= item
->type
) {
403 fprintf(stderr
, "ERROR: type mismatch between description and arguments\n");
409 if (type_desc
->type
== SIDE_TYPE_ENUM
|| type_desc
->type
== SIDE_TYPE_ENUM_BITMAP
)
410 type
= type_desc
->type
;
417 tracer_print_basic_type_header(type_desc
);
418 printf("%s", item
->u
.side_bool
? "true" : "false");
421 tracer_print_basic_type_header(type_desc
);
422 printf("%" PRIu8
, item
->u
.side_u8
);
425 tracer_print_basic_type_header(type_desc
);
426 printf("%" PRIu16
, item
->u
.side_u16
);
429 tracer_print_basic_type_header(type_desc
);
430 printf("%" PRIu32
, item
->u
.side_u32
);
433 tracer_print_basic_type_header(type_desc
);
434 printf("%" PRIu64
, item
->u
.side_u64
);
437 tracer_print_basic_type_header(type_desc
);
438 printf("%" PRId8
, item
->u
.side_s8
);
441 tracer_print_basic_type_header(type_desc
);
442 printf("%" PRId16
, item
->u
.side_s16
);
445 tracer_print_basic_type_header(type_desc
);
446 printf("%" PRId32
, item
->u
.side_s32
);
449 tracer_print_basic_type_header(type_desc
);
450 printf("%" PRId64
, item
->u
.side_s64
);
453 tracer_print_basic_type_header(type_desc
);
454 printf("0x%" PRIx8
, item
->u
.side_byte
);
458 print_enum(type_desc
, item
);
461 case SIDE_TYPE_ENUM_BITMAP
:
462 print_enum_bitmap(type_desc
, item
);
465 case SIDE_TYPE_FLOAT_BINARY16
:
466 tracer_print_basic_type_header(type_desc
);
468 printf("%g", (double) item
->u
.side_float_binary16
);
471 fprintf(stderr
, "ERROR: Unsupported binary16 float type\n");
474 case SIDE_TYPE_FLOAT_BINARY32
:
475 tracer_print_basic_type_header(type_desc
);
477 printf("%g", (double) item
->u
.side_float_binary32
);
480 fprintf(stderr
, "ERROR: Unsupported binary32 float type\n");
483 case SIDE_TYPE_FLOAT_BINARY64
:
484 tracer_print_basic_type_header(type_desc
);
486 printf("%g", (double) item
->u
.side_float_binary64
);
489 fprintf(stderr
, "ERROR: Unsupported binary64 float type\n");
492 case SIDE_TYPE_FLOAT_BINARY128
:
493 tracer_print_basic_type_header(type_desc
);
495 printf("%Lg", (long double) item
->u
.side_float_binary128
);
498 fprintf(stderr
, "ERROR: Unsupported binary128 float type\n");
501 case SIDE_TYPE_STRING
:
502 tracer_print_basic_type_header(type_desc
);
503 printf("\"%s\"", item
->u
.string
);
505 case SIDE_TYPE_STRUCT
:
506 tracer_print_struct(type_desc
, item
->u
.side_struct
);
508 case SIDE_TYPE_ARRAY
:
509 tracer_print_array(type_desc
, item
->u
.side_array
);
512 tracer_print_vla(type_desc
, item
->u
.side_vla
);
514 case SIDE_TYPE_VLA_VISITOR
:
515 tracer_print_vla_visitor(type_desc
, item
->u
.side_vla_app_visitor_ctx
);
517 case SIDE_TYPE_ARRAY_U8
:
518 case SIDE_TYPE_ARRAY_U16
:
519 case SIDE_TYPE_ARRAY_U32
:
520 case SIDE_TYPE_ARRAY_U64
:
521 case SIDE_TYPE_ARRAY_S8
:
522 case SIDE_TYPE_ARRAY_S16
:
523 case SIDE_TYPE_ARRAY_S32
:
524 case SIDE_TYPE_ARRAY_S64
:
525 case SIDE_TYPE_ARRAY_BYTE
:
526 tracer_print_array_fixint(type_desc
, item
);
528 case SIDE_TYPE_VLA_U8
:
529 case SIDE_TYPE_VLA_U16
:
530 case SIDE_TYPE_VLA_U32
:
531 case SIDE_TYPE_VLA_U64
:
532 case SIDE_TYPE_VLA_S8
:
533 case SIDE_TYPE_VLA_S16
:
534 case SIDE_TYPE_VLA_S32
:
535 case SIDE_TYPE_VLA_S64
:
536 case SIDE_TYPE_VLA_BYTE
:
537 tracer_print_vla_fixint(type_desc
, item
);
539 case SIDE_TYPE_DYNAMIC
:
540 tracer_print_basic_type_header(type_desc
);
541 tracer_print_dynamic(&item
->u
.dynamic
);
544 fprintf(stderr
, "<UNKNOWN TYPE>");
551 void tracer_print_field(const struct side_event_field
*item_desc
, const struct side_arg_vec
*item
)
553 printf("%s: ", item_desc
->field_name
);
554 tracer_print_type(&item_desc
->side_type
, item
);
558 void tracer_print_struct(const struct side_type_description
*type_desc
, const struct side_arg_vec_description
*sav_desc
)
560 const struct side_arg_vec
*sav
= sav_desc
->sav
;
561 uint32_t side_sav_len
= sav_desc
->len
;
564 if (type_desc
->u
.side_struct
->nr_fields
!= side_sav_len
) {
565 fprintf(stderr
, "ERROR: number of fields mismatch between description and arguments of structure\n");
568 print_attributes("attr", ":", type_desc
->u
.side_struct
->attr
, type_desc
->u
.side_struct
->nr_attr
);
569 printf("%s", type_desc
->u
.side_struct
->nr_attr
? ", " : "");
570 printf("fields: { ");
571 for (i
= 0; i
< side_sav_len
; i
++) {
572 printf("%s", i
? ", " : "");
573 tracer_print_field(&type_desc
->u
.side_struct
->fields
[i
], &sav
[i
]);
579 void tracer_print_array(const struct side_type_description
*type_desc
, const struct side_arg_vec_description
*sav_desc
)
581 const struct side_arg_vec
*sav
= sav_desc
->sav
;
582 uint32_t side_sav_len
= sav_desc
->len
;
585 if (type_desc
->u
.side_array
.length
!= side_sav_len
) {
586 fprintf(stderr
, "ERROR: length mismatch between description and arguments of array\n");
589 print_attributes("attr", ":", type_desc
->u
.side_array
.attr
, type_desc
->u
.side_array
.nr_attr
);
590 printf("%s", type_desc
->u
.side_array
.nr_attr
? ", " : "");
591 printf("elements: ");
593 for (i
= 0; i
< side_sav_len
; i
++) {
594 printf("%s", i
? ", " : "");
595 tracer_print_type(type_desc
->u
.side_array
.elem_type
, &sav
[i
]);
601 void tracer_print_vla(const struct side_type_description
*type_desc
, const struct side_arg_vec_description
*sav_desc
)
603 const struct side_arg_vec
*sav
= sav_desc
->sav
;
604 uint32_t side_sav_len
= sav_desc
->len
;
607 print_attributes("attr", ":", type_desc
->u
.side_vla
.attr
, type_desc
->u
.side_vla
.nr_attr
);
608 printf("%s", type_desc
->u
.side_vla
.nr_attr
? ", " : "");
609 printf("elements: ");
611 for (i
= 0; i
< side_sav_len
; i
++) {
612 printf("%s", i
? ", " : "");
613 tracer_print_type(type_desc
->u
.side_vla
.elem_type
, &sav
[i
]);
618 struct tracer_visitor_priv
{
619 const struct side_type_description
*elem_type
;
624 enum side_visitor_status
tracer_write_elem_cb(const struct side_tracer_visitor_ctx
*tracer_ctx
,
625 const struct side_arg_vec
*elem
)
627 struct tracer_visitor_priv
*tracer_priv
= tracer_ctx
->priv
;
629 printf("%s", tracer_priv
->i
++ ? ", " : "");
630 tracer_print_type(tracer_priv
->elem_type
, elem
);
631 return SIDE_VISITOR_STATUS_OK
;
635 void tracer_print_vla_visitor(const struct side_type_description
*type_desc
, void *app_ctx
)
637 enum side_visitor_status status
;
638 struct tracer_visitor_priv tracer_priv
= {
639 .elem_type
= type_desc
->u
.side_vla_visitor
.elem_type
,
642 const struct side_tracer_visitor_ctx tracer_ctx
= {
643 .write_elem
= tracer_write_elem_cb
,
644 .priv
= &tracer_priv
,
647 print_attributes("attr", ":", type_desc
->u
.side_vla_visitor
.attr
, type_desc
->u
.side_vla_visitor
.nr_attr
);
648 printf("%s", type_desc
->u
.side_vla_visitor
.nr_attr
? ", " : "");
649 printf("elements: ");
651 status
= type_desc
->u
.side_vla_visitor
.visitor(&tracer_ctx
, app_ctx
);
653 case SIDE_VISITOR_STATUS_OK
:
655 case SIDE_VISITOR_STATUS_ERROR
:
656 fprintf(stderr
, "ERROR: Visitor error\n");
662 void tracer_print_array_fixint(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
)
664 const struct side_type_description
*elem_type
= type_desc
->u
.side_array
.elem_type
;
665 uint32_t side_sav_len
= type_desc
->u
.side_array
.length
;
666 void *p
= item
->u
.side_array_fixint
;
667 enum side_type side_type
;
670 print_attributes("attr", ":", type_desc
->u
.side_array
.attr
, type_desc
->u
.side_array
.nr_attr
);
671 printf("%s", type_desc
->u
.side_array
.nr_attr
? ", " : "");
672 printf("elements: ");
673 switch (item
->type
) {
674 case SIDE_TYPE_ARRAY_U8
:
675 if (elem_type
->type
!= SIDE_TYPE_U8
)
678 case SIDE_TYPE_ARRAY_U16
:
679 if (elem_type
->type
!= SIDE_TYPE_U16
)
682 case SIDE_TYPE_ARRAY_U32
:
683 if (elem_type
->type
!= SIDE_TYPE_U32
)
686 case SIDE_TYPE_ARRAY_U64
:
687 if (elem_type
->type
!= SIDE_TYPE_U64
)
690 case SIDE_TYPE_ARRAY_S8
:
691 if (elem_type
->type
!= SIDE_TYPE_S8
)
694 case SIDE_TYPE_ARRAY_S16
:
695 if (elem_type
->type
!= SIDE_TYPE_S16
)
698 case SIDE_TYPE_ARRAY_S32
:
699 if (elem_type
->type
!= SIDE_TYPE_S32
)
702 case SIDE_TYPE_ARRAY_S64
:
703 if (elem_type
->type
!= SIDE_TYPE_S64
)
706 case SIDE_TYPE_ARRAY_BYTE
:
707 if (elem_type
->type
!= SIDE_TYPE_BYTE
)
713 side_type
= elem_type
->type
;
716 for (i
= 0; i
< side_sav_len
; i
++) {
717 struct side_arg_vec sav_elem
= {
723 sav_elem
.u
.side_u8
= ((const uint8_t *) p
)[i
];
726 sav_elem
.u
.side_s8
= ((const int8_t *) p
)[i
];
729 sav_elem
.u
.side_u16
= ((const uint16_t *) p
)[i
];
732 sav_elem
.u
.side_s16
= ((const int16_t *) p
)[i
];
735 sav_elem
.u
.side_u32
= ((const uint32_t *) p
)[i
];
738 sav_elem
.u
.side_s32
= ((const int32_t *) p
)[i
];
741 sav_elem
.u
.side_u64
= ((const uint64_t *) p
)[i
];
744 sav_elem
.u
.side_s64
= ((const int64_t *) p
)[i
];
747 sav_elem
.u
.side_byte
= ((const uint8_t *) p
)[i
];
751 fprintf(stderr
, "ERROR: Unexpected type\n");
755 printf("%s", i
? ", " : "");
756 tracer_print_type(elem_type
, &sav_elem
);
762 fprintf(stderr
, "ERROR: type mismatch\n");
766 void tracer_print_vla_fixint(const struct side_type_description
*type_desc
, const struct side_arg_vec
*item
)
768 const struct side_type_description
*elem_type
= type_desc
->u
.side_vla
.elem_type
;
769 uint32_t side_sav_len
= item
->u
.side_vla_fixint
.length
;
770 void *p
= item
->u
.side_vla_fixint
.p
;
771 enum side_type side_type
;
774 print_attributes("attr", ":", type_desc
->u
.side_vla
.attr
, type_desc
->u
.side_vla
.nr_attr
);
775 printf("%s", type_desc
->u
.side_vla
.nr_attr
? ", " : "");
776 printf("elements: ");
777 switch (item
->type
) {
778 case SIDE_TYPE_VLA_U8
:
779 if (elem_type
->type
!= SIDE_TYPE_U8
)
782 case SIDE_TYPE_VLA_U16
:
783 if (elem_type
->type
!= SIDE_TYPE_U16
)
786 case SIDE_TYPE_VLA_U32
:
787 if (elem_type
->type
!= SIDE_TYPE_U32
)
790 case SIDE_TYPE_VLA_U64
:
791 if (elem_type
->type
!= SIDE_TYPE_U64
)
794 case SIDE_TYPE_VLA_S8
:
795 if (elem_type
->type
!= SIDE_TYPE_S8
)
798 case SIDE_TYPE_VLA_S16
:
799 if (elem_type
->type
!= SIDE_TYPE_S16
)
802 case SIDE_TYPE_VLA_S32
:
803 if (elem_type
->type
!= SIDE_TYPE_S32
)
806 case SIDE_TYPE_VLA_S64
:
807 if (elem_type
->type
!= SIDE_TYPE_S64
)
810 case SIDE_TYPE_VLA_BYTE
:
811 if (elem_type
->type
!= SIDE_TYPE_BYTE
)
817 side_type
= elem_type
->type
;
820 for (i
= 0; i
< side_sav_len
; i
++) {
821 struct side_arg_vec sav_elem
= {
827 sav_elem
.u
.side_u8
= ((const uint8_t *) p
)[i
];
830 sav_elem
.u
.side_s8
= ((const int8_t *) p
)[i
];
833 sav_elem
.u
.side_u16
= ((const uint16_t *) p
)[i
];
836 sav_elem
.u
.side_s16
= ((const int16_t *) p
)[i
];
839 sav_elem
.u
.side_u32
= ((const uint32_t *) p
)[i
];
842 sav_elem
.u
.side_s32
= ((const int32_t *) p
)[i
];
845 sav_elem
.u
.side_u64
= ((const uint64_t *) p
)[i
];
848 sav_elem
.u
.side_s64
= ((const int64_t *) p
)[i
];
851 sav_elem
.u
.side_byte
= ((const uint8_t *) p
)[i
];
855 fprintf(stderr
, "ERROR: Unexpected type\n");
859 printf("%s", i
? ", " : "");
860 tracer_print_type(elem_type
, &sav_elem
);
866 fprintf(stderr
, "ERROR: type mismatch\n");
871 void tracer_print_dynamic_struct(const struct side_arg_dynamic_event_struct
*dynamic_struct
)
873 const struct side_arg_dynamic_event_field
*fields
= dynamic_struct
->fields
;
874 uint32_t len
= dynamic_struct
->len
;
877 print_attributes("attr", "::", dynamic_struct
->attr
, dynamic_struct
->nr_attr
);
878 printf("%s", dynamic_struct
->nr_attr
? ", " : "");
881 for (i
= 0; i
< len
; i
++) {
882 printf("%s", i
? ", " : "");
883 printf("%s:: ", fields
[i
].field_name
);
884 tracer_print_dynamic(&fields
[i
].elem
);
889 struct tracer_dynamic_struct_visitor_priv
{
894 enum side_visitor_status
tracer_dynamic_struct_write_elem_cb(
895 const struct side_tracer_dynamic_struct_visitor_ctx
*tracer_ctx
,
896 const struct side_arg_dynamic_event_field
*dynamic_field
)
898 struct tracer_dynamic_struct_visitor_priv
*tracer_priv
= tracer_ctx
->priv
;
900 printf("%s", tracer_priv
->i
++ ? ", " : "");
901 printf("%s:: ", dynamic_field
->field_name
);
902 tracer_print_dynamic(&dynamic_field
->elem
);
903 return SIDE_VISITOR_STATUS_OK
;
907 void tracer_print_dynamic_struct_visitor(const struct side_arg_dynamic_vec
*item
)
909 enum side_visitor_status status
;
910 struct tracer_dynamic_struct_visitor_priv tracer_priv
= {
913 const struct side_tracer_dynamic_struct_visitor_ctx tracer_ctx
= {
914 .write_field
= tracer_dynamic_struct_write_elem_cb
,
915 .priv
= &tracer_priv
,
917 void *app_ctx
= item
->u
.side_dynamic_struct_visitor
.app_ctx
;
919 print_attributes("attr", "::", item
->u
.side_dynamic_struct_visitor
.attr
, item
->u
.side_dynamic_struct_visitor
.nr_attr
);
920 printf("%s", item
->u
.side_dynamic_struct_visitor
.nr_attr
? ", " : "");
923 status
= item
->u
.side_dynamic_struct_visitor
.visitor(&tracer_ctx
, app_ctx
);
925 case SIDE_VISITOR_STATUS_OK
:
927 case SIDE_VISITOR_STATUS_ERROR
:
928 fprintf(stderr
, "ERROR: Visitor error\n");
935 void tracer_print_dynamic_vla(const struct side_arg_dynamic_vec_vla
*vla
)
937 const struct side_arg_dynamic_vec
*sav
= vla
->sav
;
938 uint32_t side_sav_len
= vla
->len
;
941 print_attributes("attr", "::", vla
->attr
, vla
->nr_attr
);
942 printf("%s", vla
->nr_attr
? ", " : "");
943 printf("elements:: ");
945 for (i
= 0; i
< side_sav_len
; i
++) {
946 printf("%s", i
? ", " : "");
947 tracer_print_dynamic(&sav
[i
]);
952 struct tracer_dynamic_vla_visitor_priv
{
957 enum side_visitor_status
tracer_dynamic_vla_write_elem_cb(
958 const struct side_tracer_dynamic_vla_visitor_ctx
*tracer_ctx
,
959 const struct side_arg_dynamic_vec
*elem
)
961 struct tracer_dynamic_vla_visitor_priv
*tracer_priv
= tracer_ctx
->priv
;
963 printf("%s", tracer_priv
->i
++ ? ", " : "");
964 tracer_print_dynamic(elem
);
965 return SIDE_VISITOR_STATUS_OK
;
969 void tracer_print_dynamic_vla_visitor(const struct side_arg_dynamic_vec
*item
)
971 enum side_visitor_status status
;
972 struct tracer_dynamic_vla_visitor_priv tracer_priv
= {
975 const struct side_tracer_dynamic_vla_visitor_ctx tracer_ctx
= {
976 .write_elem
= tracer_dynamic_vla_write_elem_cb
,
977 .priv
= &tracer_priv
,
979 void *app_ctx
= item
->u
.side_dynamic_vla_visitor
.app_ctx
;
981 print_attributes("attr", "::", item
->u
.side_dynamic_vla_visitor
.attr
, item
->u
.side_dynamic_vla_visitor
.nr_attr
);
982 printf("%s", item
->u
.side_dynamic_vla_visitor
.nr_attr
? ", " : "");
983 printf("elements:: ");
985 status
= item
->u
.side_dynamic_vla_visitor
.visitor(&tracer_ctx
, app_ctx
);
987 case SIDE_VISITOR_STATUS_OK
:
989 case SIDE_VISITOR_STATUS_ERROR
:
990 fprintf(stderr
, "ERROR: Visitor error\n");
997 void tracer_print_dynamic_basic_type_header(const struct side_arg_dynamic_vec
*item
)
999 print_attributes("attr", "::", item
->u
.side_basic
.attr
, item
->u
.side_basic
.nr_attr
);
1000 printf("%s", item
->u
.side_basic
.nr_attr
? ", " : "");
1005 void tracer_print_dynamic(const struct side_arg_dynamic_vec
*item
)
1008 switch (item
->dynamic_type
) {
1009 case SIDE_DYNAMIC_TYPE_NULL
:
1010 tracer_print_dynamic_basic_type_header(item
);
1011 printf("<NULL TYPE>");
1013 case SIDE_DYNAMIC_TYPE_BOOL
:
1014 tracer_print_dynamic_basic_type_header(item
);
1015 printf("%s", item
->u
.side_basic
.u
.side_bool
? "true" : "false");
1017 case SIDE_DYNAMIC_TYPE_U8
:
1018 tracer_print_dynamic_basic_type_header(item
);
1019 printf("%" PRIu8
, item
->u
.side_basic
.u
.side_u8
);
1021 case SIDE_DYNAMIC_TYPE_U16
:
1022 tracer_print_dynamic_basic_type_header(item
);
1023 printf("%" PRIu16
, item
->u
.side_basic
.u
.side_u16
);
1025 case SIDE_DYNAMIC_TYPE_U32
:
1026 tracer_print_dynamic_basic_type_header(item
);
1027 printf("%" PRIu32
, item
->u
.side_basic
.u
.side_u32
);
1029 case SIDE_DYNAMIC_TYPE_U64
:
1030 tracer_print_dynamic_basic_type_header(item
);
1031 printf("%" PRIu64
, item
->u
.side_basic
.u
.side_u64
);
1033 case SIDE_DYNAMIC_TYPE_S8
:
1034 tracer_print_dynamic_basic_type_header(item
);
1035 printf("%" PRId8
, item
->u
.side_basic
.u
.side_s8
);
1037 case SIDE_DYNAMIC_TYPE_S16
:
1038 tracer_print_dynamic_basic_type_header(item
);
1039 printf("%" PRId16
, item
->u
.side_basic
.u
.side_s16
);
1041 case SIDE_DYNAMIC_TYPE_S32
:
1042 tracer_print_dynamic_basic_type_header(item
);
1043 printf("%" PRId32
, item
->u
.side_basic
.u
.side_s32
);
1045 case SIDE_DYNAMIC_TYPE_S64
:
1046 tracer_print_dynamic_basic_type_header(item
);
1047 printf("%" PRId64
, item
->u
.side_basic
.u
.side_s64
);
1049 case SIDE_DYNAMIC_TYPE_BYTE
:
1050 tracer_print_dynamic_basic_type_header(item
);
1051 printf("0x%" PRIx8
, item
->u
.side_basic
.u
.side_byte
);
1054 case SIDE_DYNAMIC_TYPE_FLOAT_BINARY16
:
1055 tracer_print_dynamic_basic_type_header(item
);
1057 printf("%g", (double) item
->u
.side_basic
.u
.side_float_binary16
);
1060 fprintf(stderr
, "ERROR: Unsupported binary16 float type\n");
1063 case SIDE_DYNAMIC_TYPE_FLOAT_BINARY32
:
1064 tracer_print_dynamic_basic_type_header(item
);
1066 printf("%g", (double) item
->u
.side_basic
.u
.side_float_binary32
);
1069 fprintf(stderr
, "ERROR: Unsupported binary32 float type\n");
1072 case SIDE_DYNAMIC_TYPE_FLOAT_BINARY64
:
1073 tracer_print_dynamic_basic_type_header(item
);
1075 printf("%g", (double) item
->u
.side_basic
.u
.side_float_binary64
);
1078 fprintf(stderr
, "ERROR: Unsupported binary64 float type\n");
1081 case SIDE_DYNAMIC_TYPE_FLOAT_BINARY128
:
1082 tracer_print_dynamic_basic_type_header(item
);
1084 printf("%Lg", (long double) item
->u
.side_basic
.u
.side_float_binary128
);
1087 fprintf(stderr
, "ERROR: Unsupported binary128 float type\n");
1090 case SIDE_DYNAMIC_TYPE_STRING
:
1091 tracer_print_dynamic_basic_type_header(item
);
1092 printf("\"%s\"", item
->u
.side_basic
.u
.string
);
1094 case SIDE_DYNAMIC_TYPE_STRUCT
:
1095 tracer_print_dynamic_struct(item
->u
.side_dynamic_struct
);
1097 case SIDE_DYNAMIC_TYPE_STRUCT_VISITOR
:
1098 tracer_print_dynamic_struct_visitor(item
);
1100 case SIDE_DYNAMIC_TYPE_VLA
:
1101 tracer_print_dynamic_vla(item
->u
.side_dynamic_vla
);
1103 case SIDE_DYNAMIC_TYPE_VLA_VISITOR
:
1104 tracer_print_dynamic_vla_visitor(item
);
1107 fprintf(stderr
, "<UNKNOWN TYPE>");
1114 void tracer_print_static_fields(const struct side_event_description
*desc
,
1115 const struct side_arg_vec_description
*sav_desc
,
1118 const struct side_arg_vec
*sav
= sav_desc
->sav
;
1119 uint32_t side_sav_len
= sav_desc
->len
;
1122 printf("provider: %s, event: %s", desc
->provider_name
, desc
->event_name
);
1123 if (desc
->nr_fields
!= side_sav_len
) {
1124 fprintf(stderr
, "ERROR: number of fields mismatch between description and arguments\n");
1127 print_attributes(", attr", ":", desc
->attr
, desc
->nr_attr
);
1128 printf("%s", side_sav_len
? ", fields: [ " : "");
1129 for (i
= 0; i
< side_sav_len
; i
++) {
1130 printf("%s", i
? ", " : "");
1131 tracer_print_field(&desc
->fields
[i
], &sav
[i
]);
1139 void tracer_call(const struct side_event_description
*desc
,
1140 const struct side_arg_vec_description
*sav_desc
,
1141 void *priv
__attribute__((unused
)))
1145 tracer_print_static_fields(desc
, sav_desc
, &nr_fields
);
1149 void tracer_call_variadic(const struct side_event_description
*desc
,
1150 const struct side_arg_vec_description
*sav_desc
,
1151 const struct side_arg_dynamic_event_struct
*var_struct
,
1152 void *priv
__attribute__((unused
)))
1154 uint32_t var_struct_len
= var_struct
->len
;
1155 int nr_fields
= 0, i
;
1157 tracer_print_static_fields(desc
, sav_desc
, &nr_fields
);
1159 if (side_unlikely(!(desc
->flags
& SIDE_EVENT_FLAG_VARIADIC
))) {
1160 fprintf(stderr
, "ERROR: unexpected non-variadic event description\n");
1163 print_attributes(", attr ", "::", var_struct
->attr
, var_struct
->nr_attr
);
1164 printf("%s", var_struct_len
? ", fields:: [ " : "");
1165 for (i
= 0; i
< var_struct_len
; i
++, nr_fields
++) {
1166 printf("%s", i
? ", " : "");
1167 printf("%s:: ", var_struct
->fields
[i
].field_name
);
1168 tracer_print_dynamic(&var_struct
->fields
[i
].elem
);