src/tracer.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  */
   5
   6 #include <stdint.h>
   7 #include <inttypes.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <stdbool.h>
  11
  12 #include <side/trace.h>
  13
  14 static
  15 void tracer_print_struct(const struct side_type_description *type_desc, const struct side_arg_vec_description *sav_desc);
  16 static
  17 void tracer_print_array(const struct side_type_description *type_desc, const struct side_arg_vec_description *sav_desc);
  18 static
  19 void tracer_print_vla(const struct side_type_description *type_desc, const struct side_arg_vec_description *sav_desc);
  20 static
  21 void tracer_print_vla_visitor(const struct side_type_description *type_desc, void *app_ctx);
  22 static
  23 void tracer_print_array_fixint(const struct side_type_description *type_desc, const struct side_arg_vec *item);
  24 static
  25 void tracer_print_vla_fixint(const struct side_type_description *type_desc, const struct side_arg_vec *item);
  26 static
  27 void tracer_print_dynamic(const struct side_arg_dynamic_vec *dynamic_item);
  28
  29 static
  30 void tracer_print_attr_type(const struct side_attr *attr)
  31 {
  32         printf("{ key: \"%s\", value: ", attr->key);
  33         switch (attr->value.type) {
  34         case SIDE_ATTR_TYPE_BOOL:
  35                 printf("%s", attr->value.u.side_bool ? "true" : "false");
  36                 break;
  37         case SIDE_ATTR_TYPE_U8:
  38                 printf("%" PRIu8, attr->value.u.side_u8);
  39                 break;
  40         case SIDE_ATTR_TYPE_U16:
  41                 printf("%" PRIu16, attr->value.u.side_u16);
  42                 break;
  43         case SIDE_ATTR_TYPE_U32:
  44                 printf("%" PRIu32, attr->value.u.side_u32);
  45                 break;
  46         case SIDE_ATTR_TYPE_U64:
  47                 printf("%" PRIu64, attr->value.u.side_u64);
  48                 break;
  49         case SIDE_ATTR_TYPE_S8:
  50                 printf("%" PRId8, attr->value.u.side_s8);
  51                 break;
  52         case SIDE_ATTR_TYPE_S16:
  53                 printf("%" PRId16, attr->value.u.side_s16);
  54                 break;
  55         case SIDE_ATTR_TYPE_S32:
  56                 printf("%" PRId32, attr->value.u.side_s32);
  57                 break;
  58         case SIDE_ATTR_TYPE_S64:
  59                 printf("%" PRId64, attr->value.u.side_s64);
  60                 break;
  61         case SIDE_ATTR_TYPE_FLOAT_BINARY16:
  62 #if __HAVE_FLOAT16
  63                 printf("%g", (double) attr->value.u.side_float_binary16);
  64                 break;
  65 #else
  66                 printf("ERROR: Unsupported binary16 float type\n");
  67                 abort();
  68 #endif
  69         case SIDE_ATTR_TYPE_FLOAT_BINARY32:
  70 #if __HAVE_FLOAT32
  71                 printf("%g", (double) attr->value.u.side_float_binary32);
  72                 break;
  73 #else
  74                 printf("ERROR: Unsupported binary32 float type\n");
  75                 abort();
  76 #endif
  77         case SIDE_ATTR_TYPE_FLOAT_BINARY64:
  78 #if __HAVE_FLOAT64
  79                 printf("%g", (double) attr->value.u.side_float_binary64);
  80                 break;
  81 #else
  82                 printf("ERROR: Unsupported binary64 float type\n");
  83                 abort();
  84 #endif
  85         case SIDE_ATTR_TYPE_FLOAT_BINARY128:
  86 #if __HAVE_FLOAT128
  87                 printf("%Lg", (long double) attr->value.u.side_float_binary128);
  88                 break;
  89 #else
  90                 printf("ERROR: Unsupported binary128 float type\n");
  91                 abort();
  92 #endif
  93         case SIDE_ATTR_TYPE_STRING:
  94                 printf("\"%s\"", attr->value.u.string);
  95                 break;
  96         default:
  97                 printf("<UNKNOWN TYPE>");
  98                 abort();
  99         }
 100         printf(" }");
 101 }
 102
 103 static
 104 void print_attributes(const char *prefix_str, const struct side_attr *attr, uint32_t nr_attr)
 105 {
 106         int i;
 107
 108         if (!nr_attr)
 109                 return;
 110         printf("%s[ ", prefix_str);
 111         for (i = 0; i < nr_attr; i++) {
 112                 printf("%s", i ? ", " : "");
 113                 tracer_print_attr_type(&attr[i]);
 114         }
 115         printf(" ]");
 116 }
 117
 118 static
 119 void print_enum(const struct side_enum_mappings *side_enum_mappings, int64_t value)
 120 {
 121         int i, print_count = 0;
 122
 123         print_attributes("attr: ", side_enum_mappings->attr, side_enum_mappings->nr_attr);
 124         printf("%s", side_enum_mappings->nr_attr ? ", " : "");
 125         printf("value: %" PRId64 ", labels: [ ", value);
 126         for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
 127                 const struct side_enum_mapping *mapping = &side_enum_mappings->mappings[i];
 128
 129                 if (mapping->range_end < mapping->range_begin) {
 130                         printf("ERROR: Unexpected enum range: %" PRIu64 "-%" PRIu64 "\n",
 131                                 mapping->range_begin, mapping->range_end);
 132                         abort();
 133                 }
 134                 if (value >= mapping->range_begin && value <= mapping->range_end) {
 135                         printf("%s", print_count++ ? ", " : "");
 136                         printf("\"%s\"", mapping->label);
 137                 }
 138         }
 139         if (!print_count)
 140                 printf("<NO LABEL>");
 141         printf(" ]");
 142 }
 143
 144 static
 145 void print_enum_bitmap(const struct side_enum_bitmap_mappings *side_enum_mappings, uint64_t value)
 146 {
 147         int i, print_count = 0;
 148
 149         print_attributes("attr: ", side_enum_mappings->attr, side_enum_mappings->nr_attr);
 150         printf("%s", side_enum_mappings->nr_attr ? ", " : "");
 151         printf("value: 0x%" PRIx64 ", labels: [ ", value);
 152         for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
 153                 const struct side_enum_bitmap_mapping *mapping = &side_enum_mappings->mappings[i];
 154                 bool match = false;
 155                 int64_t bit;
 156
 157                 if (mapping->range_begin < 0 || mapping->range_end > 63
 158                                 || mapping->range_end < mapping->range_begin) {
 159                         printf("ERROR: Unexpected enum bitmap range: %" PRIu64 "-%" PRIu64 "\n",
 160                                 mapping->range_begin, mapping->range_end);
 161                         abort();
 162                 }
 163                 for (bit = mapping->range_begin; bit <= mapping->range_end; bit++) {
 164                         if (value & (1ULL << bit)) {
 165                                 match = true;
 166                                 break;
 167                         }
 168                 }
 169                 if (match) {
 170                         printf("%s", print_count++ ? ", " : "");
 171                         printf("\"%s\"", mapping->label);
 172                 }
 173         }
 174         if (!print_count)
 175                 printf("<NO LABEL>");
 176         printf(" ]");
 177 }
 178
 179 static
 180 void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item)
 181 {
 182         switch (item->type) {
 183         case SIDE_TYPE_ARRAY_U8:
 184         case SIDE_TYPE_ARRAY_U16:
 185         case SIDE_TYPE_ARRAY_U32:
 186         case SIDE_TYPE_ARRAY_U64:
 187         case SIDE_TYPE_ARRAY_S8:
 188         case SIDE_TYPE_ARRAY_S16:
 189         case SIDE_TYPE_ARRAY_S32:
 190         case SIDE_TYPE_ARRAY_S64:
 191         case SIDE_TYPE_ARRAY_BLOB:
 192                 if (type_desc->type != SIDE_TYPE_ARRAY) {
 193                         printf("ERROR: type mismatch between description and arguments\n");
 194                         abort();
 195                 }
 196                 break;
 197         case SIDE_TYPE_VLA_U8:
 198         case SIDE_TYPE_VLA_U16:
 199         case SIDE_TYPE_VLA_U32:
 200         case SIDE_TYPE_VLA_U64:
 201         case SIDE_TYPE_VLA_S8:
 202         case SIDE_TYPE_VLA_S16:
 203         case SIDE_TYPE_VLA_S32:
 204         case SIDE_TYPE_VLA_S64:
 205         case SIDE_TYPE_VLA_BLOB:
 206                 if (type_desc->type != SIDE_TYPE_VLA) {
 207                         printf("ERROR: type mismatch between description and arguments\n");
 208                         abort();
 209                 }
 210                 break;
 211
 212         default:
 213                 if (type_desc->type != item->type) {
 214                         printf("ERROR: type mismatch between description and arguments\n");
 215                         abort();
 216                 }
 217                 break;
 218         }
 219         printf("{ ");
 220         switch (item->type) {
 221         case SIDE_TYPE_BOOL:
 222                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 223                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 224                 printf("value: ");
 225                 printf("%s", item->u.side_bool ? "true" : "false");
 226                 break;
 227         case SIDE_TYPE_U8:
 228                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 229                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 230                 printf("value: ");
 231                 printf("%" PRIu8, item->u.side_u8);
 232                 break;
 233         case SIDE_TYPE_U16:
 234                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 235                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 236                 printf("value: ");
 237                 printf("%" PRIu16, item->u.side_u16);
 238                 break;
 239         case SIDE_TYPE_U32:
 240                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 241                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 242                 printf("value: ");
 243                 printf("%" PRIu32, item->u.side_u32);
 244                 break;
 245         case SIDE_TYPE_U64:
 246                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 247                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 248                 printf("value: ");
 249                 printf("%" PRIu64, item->u.side_u64);
 250                 break;
 251         case SIDE_TYPE_S8:
 252                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 253                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 254                 printf("value: ");
 255                 printf("%" PRId8, item->u.side_s8);
 256                 break;
 257         case SIDE_TYPE_S16:
 258                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 259                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 260                 printf("value: ");
 261                 printf("%" PRId16, item->u.side_s16);
 262                 break;
 263         case SIDE_TYPE_S32:
 264                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 265                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 266                 printf("value: ");
 267                 printf("%" PRId32, item->u.side_s32);
 268                 break;
 269         case SIDE_TYPE_S64:
 270                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 271                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 272                 printf("value: ");
 273                 printf("%" PRId64, item->u.side_s64);
 274                 break;
 275         case SIDE_TYPE_BLOB:
 276                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 277                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 278                 printf("value: ");
 279                 printf("0x%" PRIx8, item->u.side_blob);
 280                 break;
 281
 282         case SIDE_TYPE_ENUM_U8:
 283                 print_enum(type_desc->u.side_enum_mappings,
 284                         (int64_t) item->u.side_u8);
 285                 break;
 286         case SIDE_TYPE_ENUM_U16:
 287                 print_enum(type_desc->u.side_enum_mappings,
 288                         (int64_t) item->u.side_u16);
 289                 break;
 290         case SIDE_TYPE_ENUM_U32:
 291                 print_enum(type_desc->u.side_enum_mappings,
 292                         (int64_t) item->u.side_u32);
 293                 break;
 294         case SIDE_TYPE_ENUM_U64:
 295                 print_enum(type_desc->u.side_enum_mappings,
 296                         (int64_t) item->u.side_u64);
 297                 break;
 298         case SIDE_TYPE_ENUM_S8:
 299                 print_enum(type_desc->u.side_enum_mappings,
 300                         (int64_t) item->u.side_s8);
 301                 break;
 302         case SIDE_TYPE_ENUM_S16:
 303                 print_enum(type_desc->u.side_enum_mappings,
 304                         (int64_t) item->u.side_s16);
 305                 break;
 306         case SIDE_TYPE_ENUM_S32:
 307                 print_enum(type_desc->u.side_enum_mappings,
 308                         (int64_t) item->u.side_s32);
 309                 break;
 310         case SIDE_TYPE_ENUM_S64:
 311                 print_enum(type_desc->u.side_enum_mappings,
 312                         item->u.side_s64);
 313                 break;
 314
 315         case SIDE_TYPE_ENUM_BITMAP8:
 316                 print_enum_bitmap(type_desc->u.side_enum_bitmap_mappings,
 317                         (uint64_t) item->u.side_u8);
 318                 break;
 319         case SIDE_TYPE_ENUM_BITMAP16:
 320                 print_enum_bitmap(type_desc->u.side_enum_bitmap_mappings,
 321                         (uint64_t) item->u.side_u16);
 322                 break;
 323         case SIDE_TYPE_ENUM_BITMAP32:
 324                 print_enum_bitmap(type_desc->u.side_enum_bitmap_mappings,
 325                         (uint64_t) item->u.side_u32);
 326                 break;
 327         case SIDE_TYPE_ENUM_BITMAP64:
 328                 print_enum_bitmap(type_desc->u.side_enum_bitmap_mappings,
 329                         item->u.side_u64);
 330                 break;
 331
 332         case SIDE_TYPE_FLOAT_BINARY16:
 333                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 334                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 335                 printf("value: ");
 336 #if __HAVE_FLOAT16
 337                 printf("%g", (double) item->u.side_float_binary16);
 338                 break;
 339 #else
 340                 printf("ERROR: Unsupported binary16 float type\n");
 341                 abort();
 342 #endif
 343         case SIDE_TYPE_FLOAT_BINARY32:
 344                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 345                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 346                 printf("value: ");
 347 #if __HAVE_FLOAT32
 348                 printf("%g", (double) item->u.side_float_binary32);
 349                 break;
 350 #else
 351                 printf("ERROR: Unsupported binary32 float type\n");
 352                 abort();
 353 #endif
 354         case SIDE_TYPE_FLOAT_BINARY64:
 355                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 356                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 357                 printf("value: ");
 358 #if __HAVE_FLOAT64
 359                 printf("%g", (double) item->u.side_float_binary64);
 360                 break;
 361 #else
 362                 printf("ERROR: Unsupported binary64 float type\n");
 363                 abort();
 364 #endif
 365         case SIDE_TYPE_FLOAT_BINARY128:
 366                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 367                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 368                 printf("value: ");
 369 #if __HAVE_FLOAT128
 370                 printf("%Lg", (long double) item->u.side_float_binary128);
 371                 break;
 372 #else
 373                 printf("ERROR: Unsupported binary128 float type\n");
 374                 abort();
 375 #endif
 376         case SIDE_TYPE_STRING:
 377                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 378                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 379                 printf("value: ");
 380                 printf("\"%s\"", item->u.string);
 381                 break;
 382         case SIDE_TYPE_STRUCT:
 383                 tracer_print_struct(type_desc, item->u.side_struct);
 384                 break;
 385         case SIDE_TYPE_ARRAY:
 386                 tracer_print_array(type_desc, item->u.side_array);
 387                 break;
 388         case SIDE_TYPE_VLA:
 389                 tracer_print_vla(type_desc, item->u.side_vla);
 390                 break;
 391         case SIDE_TYPE_VLA_VISITOR:
 392                 tracer_print_vla_visitor(type_desc, item->u.side_vla_app_visitor_ctx);
 393                 break;
 394         case SIDE_TYPE_ARRAY_U8:
 395         case SIDE_TYPE_ARRAY_U16:
 396         case SIDE_TYPE_ARRAY_U32:
 397         case SIDE_TYPE_ARRAY_U64:
 398         case SIDE_TYPE_ARRAY_S8:
 399         case SIDE_TYPE_ARRAY_S16:
 400         case SIDE_TYPE_ARRAY_S32:
 401         case SIDE_TYPE_ARRAY_S64:
 402         case SIDE_TYPE_ARRAY_BLOB:
 403                 tracer_print_array_fixint(type_desc, item);
 404                 break;
 405         case SIDE_TYPE_VLA_U8:
 406         case SIDE_TYPE_VLA_U16:
 407         case SIDE_TYPE_VLA_U32:
 408         case SIDE_TYPE_VLA_U64:
 409         case SIDE_TYPE_VLA_S8:
 410         case SIDE_TYPE_VLA_S16:
 411         case SIDE_TYPE_VLA_S32:
 412         case SIDE_TYPE_VLA_S64:
 413         case SIDE_TYPE_VLA_BLOB:
 414                 tracer_print_vla_fixint(type_desc, item);
 415                 break;
 416         case SIDE_TYPE_DYNAMIC:
 417                 print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
 418                 printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
 419                 printf("element: ");
 420                 tracer_print_dynamic(&item->u.dynamic);
 421                 break;
 422         default:
 423                 printf("<UNKNOWN TYPE>");
 424                 abort();
 425         }
 426         printf(" }");
 427 }
 428
 429 static
 430 void tracer_print_field(const struct side_event_field *item_desc, const struct side_arg_vec *item)
 431 {
 432         printf("%s: ", item_desc->field_name);
 433         tracer_print_type(&item_desc->side_type, item);
 434 }
 435
 436 static
 437 void tracer_print_struct(const struct side_type_description *type_desc, const struct side_arg_vec_description *sav_desc)
 438 {
 439         const struct side_arg_vec *sav = sav_desc->sav;
 440         uint32_t side_sav_len = sav_desc->len;
 441         int i;
 442
 443         if (type_desc->u.side_struct->nr_fields != side_sav_len) {
 444                 printf("ERROR: number of fields mismatch between description and arguments of structure\n");
 445                 abort();
 446         }
 447         print_attributes("attr: ", type_desc->u.side_struct->attr, type_desc->u.side_struct->nr_attr);
 448         printf("%s", type_desc->u.side_struct->nr_attr ? ", " : "");
 449         printf("fields: { ");
 450         for (i = 0; i < side_sav_len; i++) {
 451                 printf("%s", i ? ", " : "");
 452                 tracer_print_field(&type_desc->u.side_struct->fields[i], &sav[i]);
 453         }
 454         printf(" }");
 455 }
 456
 457 static
 458 void tracer_print_array(const struct side_type_description *type_desc, const struct side_arg_vec_description *sav_desc)
 459 {
 460         const struct side_arg_vec *sav = sav_desc->sav;
 461         uint32_t side_sav_len = sav_desc->len;
 462         int i;
 463
 464         if (type_desc->u.side_array.length != side_sav_len) {
 465                 printf("ERROR: length mismatch between description and arguments of array\n");
 466                 abort();
 467         }
 468         print_attributes("attr: ", type_desc->u.side_array.attr, type_desc->u.side_array.nr_attr);
 469         printf("%s", type_desc->u.side_array.nr_attr ? ", " : "");
 470         printf("elements: ");
 471         printf("[ ");
 472         for (i = 0; i < side_sav_len; i++) {
 473                 printf("%s", i ? ", " : "");
 474                 tracer_print_type(type_desc->u.side_array.elem_type, &sav[i]);
 475         }
 476         printf(" ]");
 477 }
 478
 479 static
 480 void tracer_print_vla(const struct side_type_description *type_desc, const struct side_arg_vec_description *sav_desc)
 481 {
 482         const struct side_arg_vec *sav = sav_desc->sav;
 483         uint32_t side_sav_len = sav_desc->len;
 484         int i;
 485
 486         print_attributes("attr: ", type_desc->u.side_vla.attr, type_desc->u.side_vla.nr_attr);
 487         printf("%s", type_desc->u.side_vla.nr_attr ? ", " : "");
 488         printf("elements: ");
 489         printf("[ ");
 490         for (i = 0; i < side_sav_len; i++) {
 491                 printf("%s", i ? ", " : "");
 492                 tracer_print_type(type_desc->u.side_vla.elem_type, &sav[i]);
 493         }
 494         printf(" ]");
 495 }
 496
 497 struct tracer_visitor_priv {
 498         const struct side_type_description *elem_type;
 499         int i;
 500 };
 501
 502 static
 503 enum side_visitor_status tracer_write_elem_cb(const struct side_tracer_visitor_ctx *tracer_ctx,
 504                         const struct side_arg_vec *elem)
 505 {
 506         struct tracer_visitor_priv *tracer_priv = tracer_ctx->priv;
 507
 508         printf("%s", tracer_priv->i++ ? ", " : "");
 509         tracer_print_type(tracer_priv->elem_type, elem);
 510         return SIDE_VISITOR_STATUS_OK;
 511 }
 512
 513 static
 514 void tracer_print_vla_visitor(const struct side_type_description *type_desc, void *app_ctx)
 515 {
 516         enum side_visitor_status status;
 517         struct tracer_visitor_priv tracer_priv = {
 518                 .elem_type = type_desc->u.side_vla_visitor.elem_type,
 519                 .i = 0,
 520         };
 521         const struct side_tracer_visitor_ctx tracer_ctx = {
 522                 .write_elem = tracer_write_elem_cb,
 523                 .priv = &tracer_priv,
 524         };
 525
 526         print_attributes("attr: ", type_desc->u.side_vla_visitor.attr, type_desc->u.side_vla_visitor.nr_attr);
 527         printf("%s", type_desc->u.side_vla_visitor.nr_attr ? ", " : "");
 528         printf("elements: ");
 529         printf("[ ");
 530         status = type_desc->u.side_vla_visitor.visitor(&tracer_ctx, app_ctx);
 531         switch (status) {
 532         case SIDE_VISITOR_STATUS_OK:
 533                 break;
 534         case SIDE_VISITOR_STATUS_ERROR:
 535                 printf("ERROR: Visitor error\n");
 536                 abort();
 537         }
 538         printf(" ]");
 539 }
 540
 541 void tracer_print_array_fixint(const struct side_type_description *type_desc, const struct side_arg_vec *item)
 542 {
 543         const struct side_type_description *elem_type = type_desc->u.side_array.elem_type;
 544         uint32_t side_sav_len = type_desc->u.side_array.length;
 545         void *p = item->u.side_array_fixint;
 546         enum side_type side_type;
 547         int i;
 548
 549         print_attributes("attr: ", type_desc->u.side_array.attr, type_desc->u.side_array.nr_attr);
 550         printf("%s", type_desc->u.side_array.nr_attr ? ", " : "");
 551         printf("elements: ");
 552         switch (item->type) {
 553         case SIDE_TYPE_ARRAY_U8:
 554                 if (elem_type->type != SIDE_TYPE_U8)
 555                         goto type_error;
 556                 break;
 557         case SIDE_TYPE_ARRAY_U16:
 558                 if (elem_type->type != SIDE_TYPE_U16)
 559                         goto type_error;
 560                 break;
 561         case SIDE_TYPE_ARRAY_U32:
 562                 if (elem_type->type != SIDE_TYPE_U32)
 563                         goto type_error;
 564                 break;
 565         case SIDE_TYPE_ARRAY_U64:
 566                 if (elem_type->type != SIDE_TYPE_U64)
 567                         goto type_error;
 568                 break;
 569         case SIDE_TYPE_ARRAY_S8:
 570                 if (elem_type->type != SIDE_TYPE_S8)
 571                         goto type_error;
 572                 break;
 573         case SIDE_TYPE_ARRAY_S16:
 574                 if (elem_type->type != SIDE_TYPE_S16)
 575                         goto type_error;
 576                 break;
 577         case SIDE_TYPE_ARRAY_S32:
 578                 if (elem_type->type != SIDE_TYPE_S32)
 579                         goto type_error;
 580                 break;
 581         case SIDE_TYPE_ARRAY_S64:
 582                 if (elem_type->type != SIDE_TYPE_S64)
 583                         goto type_error;
 584                 break;
 585         case SIDE_TYPE_ARRAY_BLOB:
 586                 if (elem_type->type != SIDE_TYPE_BLOB)
 587                         goto type_error;
 588                 break;
 589         default:
 590                 goto type_error;
 591         }
 592         side_type = elem_type->type;
 593
 594         printf("[ ");
 595         for (i = 0; i < side_sav_len; i++) {
 596                 struct side_arg_vec sav_elem = {
 597                         .type = side_type,
 598                 };
 599
 600                 switch (side_type) {
 601                 case SIDE_TYPE_U8:
 602                         sav_elem.u.side_u8 = ((const uint8_t *) p)[i];
 603                         break;
 604                 case SIDE_TYPE_S8:
 605                         sav_elem.u.side_s8 = ((const int8_t *) p)[i];
 606                         break;
 607                 case SIDE_TYPE_U16:
 608                         sav_elem.u.side_u16 = ((const uint16_t *) p)[i];
 609                         break;
 610                 case SIDE_TYPE_S16:
 611                         sav_elem.u.side_s16 = ((const int16_t *) p)[i];
 612                         break;
 613                 case SIDE_TYPE_U32:
 614                         sav_elem.u.side_u32 = ((const uint32_t *) p)[i];
 615                         break;
 616                 case SIDE_TYPE_S32:
 617                         sav_elem.u.side_s32 = ((const int32_t *) p)[i];
 618                         break;
 619                 case SIDE_TYPE_U64:
 620                         sav_elem.u.side_u64 = ((const uint64_t *) p)[i];
 621                         break;
 622                 case SIDE_TYPE_S64:
 623                         sav_elem.u.side_s64 = ((const int64_t *) p)[i];
 624                         break;
 625                 case SIDE_TYPE_BLOB:
 626                         sav_elem.u.side_blob = ((const uint8_t *) p)[i];
 627                         break;
 628
 629                 default:
 630                         printf("ERROR: Unexpected type\n");
 631                         abort();
 632                 }
 633
 634                 printf("%s", i ? ", " : "");
 635                 tracer_print_type(elem_type, &sav_elem);
 636         }
 637         printf(" ]");
 638         return;
 639
 640 type_error:
 641         printf("ERROR: type mismatch\n");
 642         abort();
 643 }
 644
 645 void tracer_print_vla_fixint(const struct side_type_description *type_desc, const struct side_arg_vec *item)
 646 {
 647         const struct side_type_description *elem_type = type_desc->u.side_vla.elem_type;
 648         uint32_t side_sav_len = item->u.side_vla_fixint.length;
 649         void *p = item->u.side_vla_fixint.p;
 650         enum side_type side_type;
 651         int i;
 652
 653         print_attributes("attr: ", type_desc->u.side_vla.attr, type_desc->u.side_vla.nr_attr);
 654         printf("%s", type_desc->u.side_vla.nr_attr ? ", " : "");
 655         printf("elements: ");
 656         switch (item->type) {
 657         case SIDE_TYPE_VLA_U8:
 658                 if (elem_type->type != SIDE_TYPE_U8)
 659                         goto type_error;
 660                 break;
 661         case SIDE_TYPE_VLA_U16:
 662                 if (elem_type->type != SIDE_TYPE_U16)
 663                         goto type_error;
 664                 break;
 665         case SIDE_TYPE_VLA_U32:
 666                 if (elem_type->type != SIDE_TYPE_U32)
 667                         goto type_error;
 668                 break;
 669         case SIDE_TYPE_VLA_U64:
 670                 if (elem_type->type != SIDE_TYPE_U64)
 671                         goto type_error;
 672                 break;
 673         case SIDE_TYPE_VLA_S8:
 674                 if (elem_type->type != SIDE_TYPE_S8)
 675                         goto type_error;
 676                 break;
 677         case SIDE_TYPE_VLA_S16:
 678                 if (elem_type->type != SIDE_TYPE_S16)
 679                         goto type_error;
 680                 break;
 681         case SIDE_TYPE_VLA_S32:
 682                 if (elem_type->type != SIDE_TYPE_S32)
 683                         goto type_error;
 684                 break;
 685         case SIDE_TYPE_VLA_S64:
 686                 if (elem_type->type != SIDE_TYPE_S64)
 687                         goto type_error;
 688                 break;
 689         case SIDE_TYPE_VLA_BLOB:
 690                 if (elem_type->type != SIDE_TYPE_BLOB)
 691                         goto type_error;
 692                 break;
 693         default:
 694                 goto type_error;
 695         }
 696         side_type = elem_type->type;
 697
 698         printf("[ ");
 699         for (i = 0; i < side_sav_len; i++) {
 700                 struct side_arg_vec sav_elem = {
 701                         .type = side_type,
 702                 };
 703
 704                 switch (side_type) {
 705                 case SIDE_TYPE_U8:
 706                         sav_elem.u.side_u8 = ((const uint8_t *) p)[i];
 707                         break;
 708                 case SIDE_TYPE_S8:
 709                         sav_elem.u.side_s8 = ((const int8_t *) p)[i];
 710                         break;
 711                 case SIDE_TYPE_U16:
 712                         sav_elem.u.side_u16 = ((const uint16_t *) p)[i];
 713                         break;
 714                 case SIDE_TYPE_S16:
 715                         sav_elem.u.side_s16 = ((const int16_t *) p)[i];
 716                         break;
 717                 case SIDE_TYPE_U32:
 718                         sav_elem.u.side_u32 = ((const uint32_t *) p)[i];
 719                         break;
 720                 case SIDE_TYPE_S32:
 721                         sav_elem.u.side_s32 = ((const int32_t *) p)[i];
 722                         break;
 723                 case SIDE_TYPE_U64:
 724                         sav_elem.u.side_u64 = ((const uint64_t *) p)[i];
 725                         break;
 726                 case SIDE_TYPE_S64:
 727                         sav_elem.u.side_s64 = ((const int64_t *) p)[i];
 728                         break;
 729                 case SIDE_TYPE_BLOB:
 730                         sav_elem.u.side_blob = ((const uint8_t *) p)[i];
 731                         break;
 732
 733                 default:
 734                         printf("ERROR: Unexpected type\n");
 735                         abort();
 736                 }
 737
 738                 printf("%s", i ? ", " : "");
 739                 tracer_print_type(elem_type, &sav_elem);
 740         }
 741         printf(" ]");
 742         return;
 743
 744 type_error:
 745         printf("ERROR: type mismatch\n");
 746         abort();
 747 }
 748
 749 static
 750 void tracer_print_dynamic_struct(const struct side_arg_dynamic_event_struct *dynamic_struct)
 751 {
 752         const struct side_arg_dynamic_event_field *fields = dynamic_struct->fields;
 753         uint32_t len = dynamic_struct->len;
 754         int i;
 755
 756         printf("fields:: ");
 757         printf("[ ");
 758         for (i = 0; i < len; i++) {
 759                 printf("%s", i ? ", " : "");
 760                 printf("%s:: ", fields[i].field_name);
 761                 tracer_print_dynamic(&fields[i].elem);
 762         }
 763         printf(" ]");
 764 }
 765
 766 struct tracer_dynamic_struct_visitor_priv {
 767         int i;
 768 };
 769
 770 static
 771 enum side_visitor_status tracer_dynamic_struct_write_elem_cb(
 772                         const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
 773                         const struct side_arg_dynamic_event_field *dynamic_field)
 774 {
 775         struct tracer_dynamic_struct_visitor_priv *tracer_priv = tracer_ctx->priv;
 776
 777         printf("%s", tracer_priv->i++ ? ", " : "");
 778         printf("%s:: ", dynamic_field->field_name);
 779         tracer_print_dynamic(&dynamic_field->elem);
 780         return SIDE_VISITOR_STATUS_OK;
 781 }
 782
 783 static
 784 void tracer_print_dynamic_struct_visitor(const struct side_arg_dynamic_vec *item)
 785 {
 786         enum side_visitor_status status;
 787         struct tracer_dynamic_struct_visitor_priv tracer_priv = {
 788                 .i = 0,
 789         };
 790         const struct side_tracer_dynamic_struct_visitor_ctx tracer_ctx = {
 791                 .write_field = tracer_dynamic_struct_write_elem_cb,
 792                 .priv = &tracer_priv,
 793         };
 794         void *app_ctx = item->u.side_dynamic_struct_visitor.app_ctx;
 795
 796         printf("fields:: ");
 797         printf("[ ");
 798         status = item->u.side_dynamic_struct_visitor.visitor(&tracer_ctx, app_ctx);
 799         switch (status) {
 800         case SIDE_VISITOR_STATUS_OK:
 801                 break;
 802         case SIDE_VISITOR_STATUS_ERROR:
 803                 printf("ERROR: Visitor error\n");
 804                 abort();
 805         }
 806         printf(" ]");
 807 }
 808
 809 static
 810 void tracer_print_dynamic_vla(const struct side_arg_dynamic_vec_vla *vla)
 811 {
 812         const struct side_arg_dynamic_vec *sav = vla->sav;
 813         uint32_t side_sav_len = vla->len;
 814         int i;
 815
 816         printf("elements:: ");
 817         printf("[ ");
 818         for (i = 0; i < side_sav_len; i++) {
 819                 printf("%s", i ? ", " : "");
 820                 tracer_print_dynamic(&sav[i]);
 821         }
 822         printf(" ]");
 823 }
 824
 825 struct tracer_dynamic_vla_visitor_priv {
 826         int i;
 827 };
 828
 829 static
 830 enum side_visitor_status tracer_dynamic_vla_write_elem_cb(
 831                         const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
 832                         const struct side_arg_dynamic_vec *elem)
 833 {
 834         struct tracer_dynamic_vla_visitor_priv *tracer_priv = tracer_ctx->priv;
 835
 836         printf("%s", tracer_priv->i++ ? ", " : "");
 837         tracer_print_dynamic(elem);
 838         return SIDE_VISITOR_STATUS_OK;
 839 }
 840
 841 static
 842 void tracer_print_dynamic_vla_visitor(const struct side_arg_dynamic_vec *item)
 843 {
 844         enum side_visitor_status status;
 845         struct tracer_dynamic_vla_visitor_priv tracer_priv = {
 846                 .i = 0,
 847         };
 848         const struct side_tracer_dynamic_vla_visitor_ctx tracer_ctx = {
 849                 .write_elem = tracer_dynamic_vla_write_elem_cb,
 850                 .priv = &tracer_priv,
 851         };
 852         void *app_ctx = item->u.side_dynamic_vla_visitor.app_ctx;
 853
 854         printf("elements:: ");
 855         printf("[ ");
 856         status = item->u.side_dynamic_vla_visitor.visitor(&tracer_ctx, app_ctx);
 857         switch (status) {
 858         case SIDE_VISITOR_STATUS_OK:
 859                 break;
 860         case SIDE_VISITOR_STATUS_ERROR:
 861                 printf("ERROR: Visitor error\n");
 862                 abort();
 863         }
 864         printf(" ]");
 865 }
 866
 867 static
 868 void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
 869 {
 870         printf("{ ");
 871         print_attributes("attr:: ", item->attr, item->nr_attr);
 872         printf("%s", item->nr_attr ? ", " : "");
 873         switch (item->dynamic_type) {
 874         case SIDE_DYNAMIC_TYPE_NULL:
 875                 printf("value:: ");
 876                 printf("<NULL TYPE>");
 877                 break;
 878         case SIDE_DYNAMIC_TYPE_BOOL:
 879                 printf("value:: ");
 880                 printf("%s", item->u.side_bool ? "true" : "false");
 881                 break;
 882         case SIDE_DYNAMIC_TYPE_U8:
 883                 printf("value:: ");
 884                 printf("%" PRIu8, item->u.side_u8);
 885                 break;
 886         case SIDE_DYNAMIC_TYPE_U16:
 887                 printf("value:: ");
 888                 printf("%" PRIu16, item->u.side_u16);
 889                 break;
 890         case SIDE_DYNAMIC_TYPE_U32:
 891                 printf("value:: ");
 892                 printf("%" PRIu32, item->u.side_u32);
 893                 break;
 894         case SIDE_DYNAMIC_TYPE_U64:
 895                 printf("value:: ");
 896                 printf("%" PRIu64, item->u.side_u64);
 897                 break;
 898         case SIDE_DYNAMIC_TYPE_S8:
 899                 printf("value:: ");
 900                 printf("%" PRId8, item->u.side_s8);
 901                 break;
 902         case SIDE_DYNAMIC_TYPE_S16:
 903                 printf("value:: ");
 904                 printf("%" PRId16, item->u.side_s16);
 905                 break;
 906         case SIDE_DYNAMIC_TYPE_S32:
 907                 printf("value:: ");
 908                 printf("%" PRId32, item->u.side_s32);
 909                 break;
 910         case SIDE_DYNAMIC_TYPE_S64:
 911                 printf("value:: ");
 912                 printf("%" PRId64, item->u.side_s64);
 913                 break;
 914         case SIDE_DYNAMIC_TYPE_BLOB:
 915                 printf("value:: ");
 916                 printf("0x%" PRIx8, item->u.side_blob);
 917                 break;
 918
 919         case SIDE_DYNAMIC_TYPE_FLOAT_BINARY16:
 920                 printf("value:: ");
 921 #if __HAVE_FLOAT16
 922                 printf("%g", (double) item->u.side_float_binary16);
 923                 break;
 924 #else
 925                 printf("ERROR: Unsupported binary16 float type\n");
 926                 abort();
 927 #endif
 928         case SIDE_DYNAMIC_TYPE_FLOAT_BINARY32:
 929                 printf("value:: ");
 930 #if __HAVE_FLOAT32
 931                 printf("%g", (double) item->u.side_float_binary32);
 932                 break;
 933 #else
 934                 printf("ERROR: Unsupported binary32 float type\n");
 935                 abort();
 936 #endif
 937         case SIDE_DYNAMIC_TYPE_FLOAT_BINARY64:
 938                 printf("value:: ");
 939 #if __HAVE_FLOAT64
 940                 printf("%g", (double) item->u.side_float_binary64);
 941                 break;
 942 #else
 943                 printf("ERROR: Unsupported binary64 float type\n");
 944                 abort();
 945 #endif
 946         case SIDE_DYNAMIC_TYPE_FLOAT_BINARY128:
 947                 printf("value:: ");
 948 #if __HAVE_FLOAT128
 949                 printf("%Lg", (long double) item->u.side_float_binary128);
 950                 break;
 951 #else
 952                 printf("ERROR: Unsupported binary128 float type\n");
 953                 abort();
 954 #endif
 955         case SIDE_DYNAMIC_TYPE_STRING:
 956                 printf("value:: ");
 957                 printf("\"%s\"", item->u.string);
 958                 break;
 959         case SIDE_DYNAMIC_TYPE_STRUCT:
 960                 tracer_print_dynamic_struct(item->u.side_dynamic_struct);
 961                 break;
 962         case SIDE_DYNAMIC_TYPE_STRUCT_VISITOR:
 963                 tracer_print_dynamic_struct_visitor(item);
 964                 break;
 965         case SIDE_DYNAMIC_TYPE_VLA:
 966                 tracer_print_dynamic_vla(item->u.side_dynamic_vla);
 967                 break;
 968         case SIDE_DYNAMIC_TYPE_VLA_VISITOR:
 969                 tracer_print_dynamic_vla_visitor(item);
 970                 break;
 971         default:
 972                 printf("<UNKNOWN TYPE>");
 973                 abort();
 974         }
 975         printf(" }");
 976 }
 977
 978 static
 979 void tracer_print_static_fields(const struct side_event_description *desc,
 980                 const struct side_arg_vec_description *sav_desc,
 981                 int *nr_items)
 982 {
 983         const struct side_arg_vec *sav = sav_desc->sav;
 984         uint32_t side_sav_len = sav_desc->len;
 985         int i;
 986
 987         printf("provider: %s, event: %s", desc->provider_name, desc->event_name);
 988         if (desc->nr_fields != side_sav_len) {
 989                 printf("ERROR: number of fields mismatch between description and arguments\n");
 990                 abort();
 991         }
 992         print_attributes(", attributes: ", desc->attr, desc->nr_attr);
 993         printf("%s", side_sav_len ? ", fields: [ " : "");
 994         for (i = 0; i < side_sav_len; i++) {
 995                 printf("%s", i ? ", " : "");
 996                 tracer_print_field(&desc->fields[i], &sav[i]);
 997         }
 998         if (nr_items)
 999                 *nr_items = i;
1000 }
1001
1002 void tracer_call(const struct side_event_description *desc,
1003                 const struct side_arg_vec_description *sav_desc,
1004                 void *priv __attribute__((unused)))
1005 {
1006         int nr_fields = 0;
1007
1008         tracer_print_static_fields(desc, sav_desc, &nr_fields);
1009         if (nr_fields)
1010                 printf(" ]");
1011         printf("\n");
1012 }
1013
1014 void tracer_call_variadic(const struct side_event_description *desc,
1015                 const struct side_arg_vec_description *sav_desc,
1016                 const struct side_arg_dynamic_event_struct *var_struct,
1017                 void *priv __attribute__((unused)))
1018 {
1019         uint32_t var_struct_len = var_struct->len;
1020         int nr_fields = 0, i;
1021
1022         tracer_print_static_fields(desc, sav_desc, &nr_fields);
1023
1024         if (side_unlikely(!(desc->flags & SIDE_EVENT_FLAG_VARIADIC))) {
1025                 printf("ERROR: unexpected non-variadic event description\n");
1026                 abort();
1027         }
1028         printf("%s", var_struct_len && !nr_fields ? ", fields: [ " : "");
1029         for (i = 0; i < var_struct_len; i++, nr_fields++) {
1030                 printf("%s", nr_fields ? ", " : "");
1031                 printf("%s:: ", var_struct->fields[i].field_name);
1032                 tracer_print_dynamic(&var_struct->fields[i].elem);
1033         }
1034         if (i)
1035                 printf(" ]");
1036         printf("\n");
1037 }