include/side/trace.h

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  */
   5
   6 #ifndef _SIDE_TRACE_H
   7 #define _SIDE_TRACE_H
   8
   9 #include <stdint.h>
  10 #include <inttypes.h>
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <math.h>
  14 #include <side/macros.h>
  15
  16 /* SIDE stands for "Static Instrumentation Dynamically Enabled" */
  17
  18 //TODO: as those structures will be ABI, we need to either consider them
  19 //fixed forever, or think of a scheme that would allow their binary
  20 //representation to be extended if need be.
  21
  22 struct side_arg_vec;
  23 struct side_arg_vec_description;
  24 struct side_arg_dynamic_vec;
  25 struct side_arg_dynamic_vec_vla;
  26 struct side_type_description;
  27 struct side_event_field;
  28 struct side_tracer_visitor_ctx;
  29 struct side_tracer_dynamic_struct_visitor_ctx;
  30 struct side_tracer_dynamic_vla_visitor_ctx;
  31 struct side_event_description;
  32 struct side_arg_dynamic_event_struct;
  33
  34 enum side_type {
  35         /* Basic types */
  36         SIDE_TYPE_BOOL,
  37         SIDE_TYPE_U8,
  38         SIDE_TYPE_U16,
  39         SIDE_TYPE_U32,
  40         SIDE_TYPE_U64,
  41         SIDE_TYPE_S8,
  42         SIDE_TYPE_S16,
  43         SIDE_TYPE_S32,
  44         SIDE_TYPE_S64,
  45         SIDE_TYPE_BYTE,
  46         SIDE_TYPE_FLOAT_BINARY16,
  47         SIDE_TYPE_FLOAT_BINARY32,
  48         SIDE_TYPE_FLOAT_BINARY64,
  49         SIDE_TYPE_FLOAT_BINARY128,
  50         SIDE_TYPE_STRING,
  51
  52         /* Compound types */
  53         SIDE_TYPE_STRUCT,
  54         SIDE_TYPE_ARRAY,
  55         SIDE_TYPE_VLA,
  56         SIDE_TYPE_VLA_VISITOR,
  57
  58         SIDE_TYPE_ARRAY_U8,
  59         SIDE_TYPE_ARRAY_U16,
  60         SIDE_TYPE_ARRAY_U32,
  61         SIDE_TYPE_ARRAY_U64,
  62         SIDE_TYPE_ARRAY_S8,
  63         SIDE_TYPE_ARRAY_S16,
  64         SIDE_TYPE_ARRAY_S32,
  65         SIDE_TYPE_ARRAY_S64,
  66         SIDE_TYPE_ARRAY_BYTE,
  67
  68         SIDE_TYPE_VLA_U8,
  69         SIDE_TYPE_VLA_U16,
  70         SIDE_TYPE_VLA_U32,
  71         SIDE_TYPE_VLA_U64,
  72         SIDE_TYPE_VLA_S8,
  73         SIDE_TYPE_VLA_S16,
  74         SIDE_TYPE_VLA_S32,
  75         SIDE_TYPE_VLA_S64,
  76         SIDE_TYPE_VLA_BYTE,
  77
  78         /* Enumeration types */
  79         SIDE_TYPE_ENUM,
  80         SIDE_TYPE_ENUM_BITMAP,
  81
  82         /* Dynamic type */
  83         SIDE_TYPE_DYNAMIC,
  84 };
  85
  86 enum side_dynamic_type {
  87         /* Basic types */
  88         SIDE_DYNAMIC_TYPE_NULL,
  89         SIDE_DYNAMIC_TYPE_BOOL,
  90         SIDE_DYNAMIC_TYPE_U8,
  91         SIDE_DYNAMIC_TYPE_U16,
  92         SIDE_DYNAMIC_TYPE_U32,
  93         SIDE_DYNAMIC_TYPE_U64,
  94         SIDE_DYNAMIC_TYPE_S8,
  95         SIDE_DYNAMIC_TYPE_S16,
  96         SIDE_DYNAMIC_TYPE_S32,
  97         SIDE_DYNAMIC_TYPE_S64,
  98         SIDE_DYNAMIC_TYPE_BYTE,
  99         SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
 100         SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
 101         SIDE_DYNAMIC_TYPE_FLOAT_BINARY64,
 102         SIDE_DYNAMIC_TYPE_FLOAT_BINARY128,
 103         SIDE_DYNAMIC_TYPE_STRING,
 104
 105         /* Compound types */
 106         SIDE_DYNAMIC_TYPE_STRUCT,
 107         SIDE_DYNAMIC_TYPE_STRUCT_VISITOR,
 108         SIDE_DYNAMIC_TYPE_VLA,
 109         SIDE_DYNAMIC_TYPE_VLA_VISITOR,
 110 };
 111
 112 enum side_attr_type {
 113         SIDE_ATTR_TYPE_NULL,
 114         SIDE_ATTR_TYPE_BOOL,
 115         SIDE_ATTR_TYPE_U8,
 116         SIDE_ATTR_TYPE_U16,
 117         SIDE_ATTR_TYPE_U32,
 118         SIDE_ATTR_TYPE_U64,
 119         SIDE_ATTR_TYPE_S8,
 120         SIDE_ATTR_TYPE_S16,
 121         SIDE_ATTR_TYPE_S32,
 122         SIDE_ATTR_TYPE_S64,
 123         SIDE_ATTR_TYPE_FLOAT_BINARY16,
 124         SIDE_ATTR_TYPE_FLOAT_BINARY32,
 125         SIDE_ATTR_TYPE_FLOAT_BINARY64,
 126         SIDE_ATTR_TYPE_FLOAT_BINARY128,
 127         SIDE_ATTR_TYPE_STRING,
 128 };
 129
 130 enum side_loglevel {
 131         SIDE_LOGLEVEL_EMERG = 0,
 132         SIDE_LOGLEVEL_ALERT = 1,
 133         SIDE_LOGLEVEL_CRIT = 2,
 134         SIDE_LOGLEVEL_ERR = 3,
 135         SIDE_LOGLEVEL_WARNING = 4,
 136         SIDE_LOGLEVEL_NOTICE = 5,
 137         SIDE_LOGLEVEL_INFO = 6,
 138         SIDE_LOGLEVEL_DEBUG = 7,
 139 };
 140
 141 enum side_visitor_status {
 142         SIDE_VISITOR_STATUS_OK = 0,
 143         SIDE_VISITOR_STATUS_ERROR = -1,
 144 };
 145
 146 enum side_error {
 147         SIDE_ERROR_OK = 0,
 148         SIDE_ERROR_INVAL = 1,
 149         SIDE_ERROR_EXIST = 2,
 150         SIDE_ERROR_NOMEM = 3,
 151         SIDE_ERROR_NOENT = 4,
 152 };
 153
 154 typedef enum side_visitor_status (*side_visitor)(
 155                 const struct side_tracer_visitor_ctx *tracer_ctx,
 156                 void *app_ctx);
 157 typedef enum side_visitor_status (*side_dynamic_struct_visitor)(
 158                 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
 159                 void *app_ctx);
 160 typedef enum side_visitor_status (*side_dynamic_vla_visitor)(
 161                 const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
 162                 void *app_ctx);
 163
 164 struct side_attr_value {
 165         uint32_t type;  /* enum side_attr_type */
 166         union {
 167                 uint8_t side_bool;
 168                 uint8_t side_u8;
 169                 uint16_t side_u16;
 170                 uint32_t side_u32;
 171                 uint64_t side_u64;
 172                 int8_t side_s8;
 173                 int16_t side_s16;
 174                 int32_t side_s32;
 175                 int64_t side_s64;
 176 #if __HAVE_FLOAT16
 177                 _Float16 side_float_binary16;
 178 #endif
 179 #if __HAVE_FLOAT32
 180                 _Float32 side_float_binary32;
 181 #endif
 182 #if __HAVE_FLOAT64
 183                 _Float64 side_float_binary64;
 184 #endif
 185 #if __HAVE_FLOAT128
 186                 _Float128 side_float_binary128;
 187 #endif
 188                 const char *string;
 189         } u;
 190 };
 191
 192 /* User attributes. */
 193 struct side_attr {
 194         const char *key;
 195         const struct side_attr_value value;
 196 };
 197
 198 struct side_enum_mapping {
 199         int64_t range_begin;
 200         int64_t range_end;
 201         const char *label;
 202 };
 203
 204 struct side_enum_mappings {
 205         const struct side_enum_mapping *mappings;
 206         const struct side_attr *attr;
 207         uint32_t nr_mappings;
 208         uint32_t nr_attr;
 209 };
 210
 211 struct side_enum_bitmap_mapping {
 212         uint64_t range_begin;
 213         uint64_t range_end;
 214         const char *label;
 215 };
 216
 217 struct side_enum_bitmap_mappings {
 218         const struct side_enum_bitmap_mapping *mappings;
 219         const struct side_attr *attr;
 220         uint32_t nr_mappings;
 221         uint32_t nr_attr;
 222 };
 223
 224 struct side_type_struct {
 225         uint32_t nr_fields;
 226         uint32_t nr_attr;
 227         const struct side_event_field *fields;
 228         const struct side_attr *attr;
 229 };
 230
 231 struct side_type_description {
 232         uint32_t type;  /* enum side_type */
 233         union {
 234                 /* Basic types */
 235                 struct {
 236                         const struct side_attr *attr;
 237                         uint32_t nr_attr;
 238                 } side_basic;
 239
 240                 /* Compound types */
 241                 struct {
 242                         const struct side_type_description *elem_type;
 243                         const struct side_attr *attr;
 244                         uint32_t length;
 245                         uint32_t nr_attr;
 246                 } side_array;
 247                 struct {
 248                         const struct side_type_description *elem_type;
 249                         const struct side_attr *attr;
 250                         uint32_t nr_attr;
 251                 } side_vla;
 252                 struct {
 253                         const struct side_type_description *elem_type;
 254                         side_visitor visitor;
 255                         const struct side_attr *attr;
 256                         uint32_t nr_attr;
 257                 } side_vla_visitor;
 258                 const struct side_type_struct *side_struct;
 259
 260                 /* Enumeration types */
 261                 struct {
 262                         const struct side_enum_mappings *mappings;
 263                         const struct side_type_description *elem_type;
 264                 } side_enum;
 265                 struct {
 266                         const struct side_enum_bitmap_mappings *mappings;
 267                         const struct side_type_description *elem_type;
 268                 } side_enum_bitmap;
 269         } u;
 270 };
 271
 272 struct side_event_field {
 273         const char *field_name;
 274         struct side_type_description side_type;
 275 };
 276
 277 enum side_event_flags {
 278         SIDE_EVENT_FLAG_VARIADIC = (1 << 0),
 279 };
 280
 281 struct side_callback {
 282         union {
 283                 void (*call)(const struct side_event_description *desc,
 284                         const struct side_arg_vec_description *sav_desc,
 285                         void *priv);
 286                 void (*call_variadic)(const struct side_event_description *desc,
 287                         const struct side_arg_vec_description *sav_desc,
 288                         const struct side_arg_dynamic_event_struct *var_struct,
 289                         void *priv);
 290         } u;
 291         void *priv;
 292 };
 293
 294 struct side_event_description {
 295         uint32_t version;
 296         uint32_t *enabled;
 297         uint32_t loglevel;      /* enum side_loglevel */
 298         uint32_t nr_fields;
 299         uint32_t nr_attr;
 300         uint32_t _unused;
 301         uint64_t flags;
 302         const char *provider_name;
 303         const char *event_name;
 304         const struct side_event_field *fields;
 305         const struct side_attr *attr;
 306         const struct side_callback *callbacks;
 307 };
 308
 309 struct side_arg_dynamic_vec {
 310         uint32_t dynamic_type;  /* enum side_dynamic_type */
 311         union {
 312                 /* Basic types */
 313                 struct {
 314                         const struct side_attr *attr;
 315                         uint32_t nr_attr;
 316                         union {
 317                                 uint8_t side_bool;
 318                                 uint8_t side_u8;
 319                                 uint16_t side_u16;
 320                                 uint32_t side_u32;
 321                                 uint64_t side_u64;
 322                                 int8_t side_s8;
 323                                 int16_t side_s16;
 324                                 int32_t side_s32;
 325                                 int64_t side_s64;
 326                                 uint8_t side_byte;
 327 #if __HAVE_FLOAT16
 328                                 _Float16 side_float_binary16;
 329 #endif
 330 #if __HAVE_FLOAT32
 331                                 _Float32 side_float_binary32;
 332 #endif
 333 #if __HAVE_FLOAT64
 334                                 _Float64 side_float_binary64;
 335 #endif
 336 #if __HAVE_FLOAT128
 337                                 _Float128 side_float_binary128;
 338 #endif
 339                                 const char *string;
 340                         } u;
 341                 } side_basic;
 342
 343                 /* Compound types */
 344                 const struct side_arg_dynamic_event_struct *side_dynamic_struct;
 345                 struct {
 346                         void *app_ctx;
 347                         side_dynamic_struct_visitor visitor;
 348                         const struct side_attr *attr;
 349                         uint32_t nr_attr;
 350                 } side_dynamic_struct_visitor;
 351                 const struct side_arg_dynamic_vec_vla *side_dynamic_vla;
 352                 struct {
 353                         void *app_ctx;
 354                         side_dynamic_vla_visitor visitor;
 355                         const struct side_attr *attr;
 356                         uint32_t nr_attr;
 357                 } side_dynamic_vla_visitor;
 358         } u;
 359 };
 360
 361 struct side_arg_dynamic_vec_vla {
 362         const struct side_arg_dynamic_vec *sav;
 363         const struct side_attr *attr;
 364         uint32_t len;
 365         uint32_t nr_attr;
 366 };
 367
 368 struct side_arg_dynamic_event_field {
 369         const char *field_name;
 370         const struct side_arg_dynamic_vec elem;
 371 };
 372
 373 struct side_arg_dynamic_event_struct {
 374         const struct side_arg_dynamic_event_field *fields;
 375         const struct side_attr *attr;
 376         uint32_t len;
 377         uint32_t nr_attr;
 378 };
 379
 380 struct side_arg_vec {
 381         enum side_type type;
 382         union {
 383                 /* Basic types */
 384                 uint8_t side_bool;
 385                 uint8_t side_u8;
 386                 uint16_t side_u16;
 387                 uint32_t side_u32;
 388                 uint64_t side_u64;
 389                 int8_t side_s8;
 390                 int16_t side_s16;
 391                 int32_t side_s32;
 392                 int64_t side_s64;
 393                 uint8_t side_byte;
 394 #if __HAVE_FLOAT16
 395                 _Float16 side_float_binary16;
 396 #endif
 397 #if __HAVE_FLOAT32
 398                 _Float32 side_float_binary32;
 399 #endif
 400 #if __HAVE_FLOAT64
 401                 _Float64 side_float_binary64;
 402 #endif
 403 #if __HAVE_FLOAT128
 404                 _Float128 side_float_binary128;
 405 #endif
 406                 const char *string;
 407
 408                 /* Compound types */
 409                 const struct side_arg_vec_description *side_struct;
 410                 const struct side_arg_vec_description *side_array;
 411                 const struct side_arg_vec_description *side_vla;
 412                 void *side_vla_app_visitor_ctx;
 413                 void *side_array_fixint;
 414                 struct {
 415                         void *p;
 416                         uint32_t length;
 417                 } side_vla_fixint;
 418
 419                 /* Dynamic type */
 420                 struct side_arg_dynamic_vec dynamic;
 421         } u;
 422 };
 423
 424 struct side_arg_vec_description {
 425         const struct side_arg_vec *sav;
 426         uint32_t len;
 427 };
 428
 429 /* The visitor pattern is a double-dispatch visitor. */
 430 struct side_tracer_visitor_ctx {
 431         enum side_visitor_status (*write_elem)(
 432                         const struct side_tracer_visitor_ctx *tracer_ctx,
 433                         const struct side_arg_vec *elem);
 434         void *priv;             /* Private tracer context. */
 435 };
 436
 437 struct side_tracer_dynamic_struct_visitor_ctx {
 438         enum side_visitor_status (*write_field)(
 439                         const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
 440                         const struct side_arg_dynamic_event_field *dynamic_field);
 441         void *priv;             /* Private tracer context. */
 442 };
 443
 444 struct side_tracer_dynamic_vla_visitor_ctx {
 445         enum side_visitor_status (*write_elem)(
 446                         const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
 447                         const struct side_arg_dynamic_vec *elem);
 448         void *priv;             /* Private tracer context. */
 449 };
 450
 451 /* Event and type attributes */
 452
 453 #define side_attr(_key, _value) \
 454         { \
 455                 .key = _key, \
 456                 .value = SIDE_PARAM(_value), \
 457         }
 458
 459 #define side_attr_list(...) \
 460         SIDE_COMPOUND_LITERAL(const struct side_attr, __VA_ARGS__)
 461
 462 #define side_attr_null(_val)            { .type = SIDE_ATTR_TYPE_NULL }
 463 #define side_attr_bool(_val)            { .type = SIDE_ATTR_TYPE_BOOL, .u = { .side_bool = !!(_val) } }
 464 #define side_attr_u8(_val)              { .type = SIDE_ATTR_TYPE_U8, .u = { .side_u8 = (_val) } }
 465 #define side_attr_u16(_val)             { .type = SIDE_ATTR_TYPE_U16, .u = { .side_u16 = (_val) } }
 466 #define side_attr_u32(_val)             { .type = SIDE_ATTR_TYPE_U32, .u = { .side_u32 = (_val) } }
 467 #define side_attr_u64(_val)             { .type = SIDE_ATTR_TYPE_U64, .u = { .side_u64 = (_val) } }
 468 #define side_attr_s8(_val)              { .type = SIDE_ATTR_TYPE_S8, .u = { .side_s8 = (_val) } }
 469 #define side_attr_s16(_val)             { .type = SIDE_ATTR_TYPE_S16, .u = { .side_s16 = (_val) } }
 470 #define side_attr_s32(_val)             { .type = SIDE_ATTR_TYPE_S32, .u = { .side_s32 = (_val) } }
 471 #define side_attr_s64(_val)             { .type = SIDE_ATTR_TYPE_S64, .u = { .side_s64 = (_val) } }
 472 #define side_attr_float_binary16(_val)  { .type = SIDE_ATTR_TYPE_FLOAT_BINARY16, .u = { .side_float_binary16 = (_val) } }
 473 #define side_attr_float_binary32(_val)  { .type = SIDE_ATTR_TYPE_FLOAT_BINARY32, .u = { .side_float_binary32 = (_val) } }
 474 #define side_attr_float_binary64(_val)  { .type = SIDE_ATTR_TYPE_FLOAT_BINARY64, .u = { .side_float_binary64 = (_val) } }
 475 #define side_attr_float_binary128(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY128, .u = { .side_float_binary128 = (_val) } }
 476 #define side_attr_string(_val)          { .type = SIDE_ATTR_TYPE_STRING, .u = { .string = (_val) } }
 477
 478 /* Static field definition */
 479
 480 #define _side_type_basic(_type, _attr) \
 481         { \
 482                 .type = _type, \
 483                 .u = { \
 484                         .side_basic = { \
 485                                 .attr = _attr, \
 486                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 487                         }, \
 488                 }, \
 489         }
 490
 491 #define side_type_bool(_attr)                           _side_type_basic(SIDE_TYPE_BOOL, SIDE_PARAM(_attr))
 492 #define side_type_u8(_attr)                             _side_type_basic(SIDE_TYPE_U8, SIDE_PARAM(_attr))
 493 #define side_type_u16(_attr)                            _side_type_basic(SIDE_TYPE_U16, SIDE_PARAM(_attr))
 494 #define side_type_u32(_attr)                            _side_type_basic(SIDE_TYPE_U32, SIDE_PARAM(_attr))
 495 #define side_type_u64(_attr)                            _side_type_basic(SIDE_TYPE_U64, SIDE_PARAM(_attr))
 496 #define side_type_s8(_attr)                             _side_type_basic(SIDE_TYPE_S8, SIDE_PARAM(_attr))
 497 #define side_type_s16(_attr)                            _side_type_basic(SIDE_TYPE_S16, SIDE_PARAM(_attr))
 498 #define side_type_s32(_attr)                            _side_type_basic(SIDE_TYPE_S32, SIDE_PARAM(_attr))
 499 #define side_type_s64(_attr)                            _side_type_basic(SIDE_TYPE_S64, SIDE_PARAM(_attr))
 500 #define side_type_byte(_attr)                           _side_type_basic(SIDE_TYPE_BYTE, SIDE_PARAM(_attr))
 501 #define side_type_float_binary16(_attr)                 _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
 502 #define side_type_float_binary32(_attr)                 _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
 503 #define side_type_float_binary64(_attr)                 _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
 504 #define side_type_float_binary128(_attr)                _side_type_basic(SIDE_TYPE_FLOAT_BINARY128, SIDE_PARAM(_attr))
 505 #define side_type_string(_attr)                         _side_type_basic(SIDE_TYPE_STRING, SIDE_PARAM(_attr))
 506 #define side_type_dynamic(_attr)                        _side_type_basic(SIDE_TYPE_DYNAMIC, SIDE_PARAM(_attr))
 507
 508 #define _side_field(_name, _type) \
 509         { \
 510                 .field_name = _name, \
 511                 .side_type = _type, \
 512         }
 513
 514 #define side_field_bool(_name, _attr)                   _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
 515 #define side_field_u8(_name, _attr)                     _side_field(_name, side_type_u8(SIDE_PARAM(_attr)))
 516 #define side_field_u16(_name, _attr)                    _side_field(_name, side_type_u16(SIDE_PARAM(_attr)))
 517 #define side_field_u32(_name, _attr)                    _side_field(_name, side_type_u32(SIDE_PARAM(_attr)))
 518 #define side_field_u64(_name, _attr)                    _side_field(_name, side_type_u64(SIDE_PARAM(_attr)))
 519 #define side_field_s8(_name, _attr)                     _side_field(_name, side_type_s8(SIDE_PARAM(_attr)))
 520 #define side_field_s16(_name, _attr)                    _side_field(_name, side_type_s16(SIDE_PARAM(_attr)))
 521 #define side_field_s32(_name, _attr)                    _side_field(_name, side_type_s32(SIDE_PARAM(_attr)))
 522 #define side_field_s64(_name, _attr)                    _side_field(_name, side_type_s64(SIDE_PARAM(_attr)))
 523 #define side_field_byte(_name, _attr)                   _side_field(_name, side_type_byte(SIDE_PARAM(_attr)))
 524 #define side_field_float_binary16(_name, _attr)         _side_field(_name, side_type_float_binary16(SIDE_PARAM(_attr)))
 525 #define side_field_float_binary32(_name, _attr)         _side_field(_name, side_type_float_binary32(SIDE_PARAM(_attr)))
 526 #define side_field_float_binary64(_name, _attr)         _side_field(_name, side_type_float_binary64(SIDE_PARAM(_attr)))
 527 #define side_field_float_binary128(_name, _attr)        _side_field(_name, side_type_float_binary128(SIDE_PARAM(_attr)))
 528 #define side_field_string(_name, _attr)                 _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
 529 #define side_field_dynamic(_name, _attr)                _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
 530
 531 #define side_type_enum(_mappings, _elem_type) \
 532         { \
 533                 .type = SIDE_TYPE_ENUM, \
 534                 .u = { \
 535                         .side_enum = { \
 536                                 .mappings = _mappings, \
 537                                 .elem_type = _elem_type, \
 538                         }, \
 539                 }, \
 540         }
 541 #define side_field_enum(_name, _mappings, _elem_type) \
 542         _side_field(_name, side_type_enum(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
 543
 544 #define side_type_enum_bitmap(_mappings, _elem_type) \
 545         { \
 546                 .type = SIDE_TYPE_ENUM_BITMAP, \
 547                 .u = { \
 548                         .side_enum_bitmap = { \
 549                                 .mappings = _mappings, \
 550                                 .elem_type = _elem_type, \
 551                         }, \
 552                 }, \
 553         }
 554 #define side_field_enum_bitmap(_name, _mappings, _elem_type) \
 555         _side_field(_name, side_type_enum_bitmap(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
 556
 557 #define side_type_struct(_struct) \
 558         { \
 559                 .type = SIDE_TYPE_STRUCT, \
 560                 .u = { \
 561                         .side_struct = _struct, \
 562                 }, \
 563         }
 564 #define side_field_struct(_name, _struct) \
 565         _side_field(_name, side_type_struct(SIDE_PARAM(_struct)))
 566
 567 #define _side_type_struct_define(_fields, _attr) \
 568         { \
 569                 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
 570                 .nr_attr  = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 571                 .fields = _fields, \
 572                 .attr = _attr, \
 573         }
 574
 575 #define side_define_struct(_identifier, _fields, _attr) \
 576         const struct side_type_struct _identifier = _side_type_struct_define(SIDE_PARAM(_fields), SIDE_PARAM(_attr))
 577
 578 #define side_struct_literal(_fields, _attr) \
 579         SIDE_COMPOUND_LITERAL(const struct side_type_struct, \
 580                 _side_type_struct_define(SIDE_PARAM(_fields), SIDE_PARAM(_attr)))
 581
 582 #define side_type_array(_elem_type, _length, _attr) \
 583         { \
 584                 .type = SIDE_TYPE_ARRAY, \
 585                 .u = { \
 586                         .side_array = { \
 587                                 .elem_type = _elem_type, \
 588                                 .attr = _attr, \
 589                                 .length = _length, \
 590                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 591                         }, \
 592                 }, \
 593         }
 594 #define side_field_array(_name, _elem_type, _length, _attr) \
 595         _side_field(_name, side_type_array(SIDE_PARAM(_elem_type), _length, SIDE_PARAM(_attr)))
 596
 597 #define side_type_vla(_elem_type, _attr) \
 598         { \
 599                 .type = SIDE_TYPE_VLA, \
 600                 .u = { \
 601                         .side_vla = { \
 602                                 .elem_type = _elem_type, \
 603                                 .attr = _attr, \
 604                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 605                         }, \
 606                 }, \
 607         }
 608 #define side_field_vla(_name, _elem_type, _attr) \
 609         _side_field(_name, side_type_vla(SIDE_PARAM(_elem_type), SIDE_PARAM(_attr)))
 610
 611 #define side_type_vla_visitor(_elem_type, _visitor, _attr) \
 612         { \
 613                 .type = SIDE_TYPE_VLA_VISITOR, \
 614                 .u = { \
 615                         .side_vla_visitor = { \
 616                                 .elem_type = SIDE_PARAM(_elem_type), \
 617                                 .visitor = _visitor, \
 618                                 .attr = _attr, \
 619                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 620                         }, \
 621                 }, \
 622         }
 623 #define side_field_vla_visitor(_name, _elem_type, _visitor, _attr) \
 624         _side_field(_name, side_type_vla_visitor(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)))
 625
 626 #define side_elem(...) \
 627         SIDE_COMPOUND_LITERAL(const struct side_type_description, __VA_ARGS__)
 628
 629 #define side_field_list(...) \
 630         SIDE_COMPOUND_LITERAL(const struct side_event_field, __VA_ARGS__)
 631
 632 /* Static field arguments */
 633
 634 #define side_arg_bool(_val)             { .type = SIDE_TYPE_BOOL, .u = { .side_bool = !!(_val) } }
 635 #define side_arg_u8(_val)               { .type = SIDE_TYPE_U8, .u = { .side_u8 = (_val) } }
 636 #define side_arg_u16(_val)              { .type = SIDE_TYPE_U16, .u = { .side_u16 = (_val) } }
 637 #define side_arg_u32(_val)              { .type = SIDE_TYPE_U32, .u = { .side_u32 = (_val) } }
 638 #define side_arg_u64(_val)              { .type = SIDE_TYPE_U64, .u = { .side_u64 = (_val) } }
 639 #define side_arg_s8(_val)               { .type = SIDE_TYPE_S8, .u = { .side_s8 = (_val) } }
 640 #define side_arg_s16(_val)              { .type = SIDE_TYPE_S16, .u = { .side_s16 = (_val) } }
 641 #define side_arg_s32(_val)              { .type = SIDE_TYPE_S32, .u = { .side_s32 = (_val) } }
 642 #define side_arg_s64(_val)              { .type = SIDE_TYPE_S64, .u = { .side_s64 = (_val) } }
 643 #define side_arg_byte(_val)             { .type = SIDE_TYPE_BYTE, .u = { .side_byte = (_val) } }
 644 #define side_arg_enum_bitmap8(_val)     { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .side_u8 = (_val) } }
 645 #define side_arg_enum_bitmap16(_val)    { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .side_u16 = (_val) } }
 646 #define side_arg_enum_bitmap32(_val)    { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .side_u32 = (_val) } }
 647 #define side_arg_enum_bitmap64(_val)    { .type = SIDE_TYPE_ENUM_BITMAP64, .u = { .side_u64 = (_val) } }
 648 #define side_arg_enum_bitmap_array(_side_type)  { .type = SIDE_TYPE_ENUM_BITMAP_ARRAY, .u = { .side_array = (_side_type) } }
 649 #define side_arg_enum_bitmap_vla(_side_type)    { .type = SIDE_TYPE_ENUM_BITMAP_VLA, .u = { .side_vla = (_side_type) } }
 650 #define side_arg_float_binary16(_val)   { .type = SIDE_TYPE_FLOAT_BINARY16, .u = { .side_float_binary16 = (_val) } }
 651 #define side_arg_float_binary32(_val)   { .type = SIDE_TYPE_FLOAT_BINARY32, .u = { .side_float_binary32 = (_val) } }
 652 #define side_arg_float_binary64(_val)   { .type = SIDE_TYPE_FLOAT_BINARY64, .u = { .side_float_binary64 = (_val) } }
 653 #define side_arg_float_binary128(_val)  { .type = SIDE_TYPE_FLOAT_BINARY128, .u = { .side_float_binary128 = (_val) } }
 654
 655 #define side_arg_string(_val)           { .type = SIDE_TYPE_STRING, .u = { .string = (_val) } }
 656 #define side_arg_struct(_side_type)     { .type = SIDE_TYPE_STRUCT, .u = { .side_struct = (_side_type) } }
 657 #define side_arg_array(_side_type)      { .type = SIDE_TYPE_ARRAY, .u = { .side_array = (_side_type) } }
 658 #define side_arg_vla(_side_type)        { .type = SIDE_TYPE_VLA, .u = { .side_vla = (_side_type) } }
 659 #define side_arg_vla_visitor(_ctx)      { .type = SIDE_TYPE_VLA_VISITOR, .u = { .side_vla_app_visitor_ctx = (_ctx) } }
 660
 661 #define side_arg_array_u8(_ptr)         { .type = SIDE_TYPE_ARRAY_U8, .u = { .side_array_fixint = (_ptr) } }
 662 #define side_arg_array_u16(_ptr)        { .type = SIDE_TYPE_ARRAY_U16, .u = { .side_array_fixint = (_ptr) } }
 663 #define side_arg_array_u32(_ptr)        { .type = SIDE_TYPE_ARRAY_U32, .u = { .side_array_fixint = (_ptr) } }
 664 #define side_arg_array_u64(_ptr)        { .type = SIDE_TYPE_ARRAY_U64, .u = { .side_array_fixint = (_ptr) } }
 665 #define side_arg_array_s8(_ptr)         { .type = SIDE_TYPE_ARRAY_S8, .u = { .side_array_fixint = (_ptr) } }
 666 #define side_arg_array_s16(_ptr)        { .type = SIDE_TYPE_ARRAY_S16, .u = { .side_array_fixint  = (_ptr) } }
 667 #define side_arg_array_s32(_ptr)        { .type = SIDE_TYPE_ARRAY_S32, .u = { .side_array_fixint = (_ptr) } }
 668 #define side_arg_array_s64(_ptr)        { .type = SIDE_TYPE_ARRAY_S64, .u = { .side_array_fixint = (_ptr) } }
 669 #define side_arg_array_byte(_ptr)       { .type = SIDE_TYPE_ARRAY_BYTE, .u = { .side_array_fixint = (_ptr) } }
 670
 671 #define side_arg_vla_u8(_ptr, _length)  { .type = SIDE_TYPE_VLA_U8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } }
 672 #define side_arg_vla_u16(_ptr, _length) { .type = SIDE_TYPE_VLA_U16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 673 #define side_arg_vla_u32(_ptr, _length) { .type = SIDE_TYPE_VLA_U32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 674 #define side_arg_vla_u64(_ptr, _length) { .type = SIDE_TYPE_VLA_U64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 675 #define side_arg_vla_s8(_ptr, _length)  { .type = SIDE_TYPE_VLA_S8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 676 #define side_arg_vla_s16(_ptr, _length) { .type = SIDE_TYPE_VLA_S16, .u = { .side_vla_fixint  = { .p = (_ptr), .length = (_length) } } }
 677 #define side_arg_vla_s32(_ptr, _length) { .type = SIDE_TYPE_VLA_S32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 678 #define side_arg_vla_s64(_ptr, _length) { .type = SIDE_TYPE_VLA_S64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 679 #define side_arg_vla_byte(_ptr, _length) { .type = SIDE_TYPE_VLA_BYTE, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 680
 681 #define side_arg_dynamic(_dynamic_arg_type) \
 682         { \
 683                 .type = SIDE_TYPE_DYNAMIC, \
 684                 .u = { \
 685                         .dynamic = _dynamic_arg_type, \
 686                 }, \
 687         }
 688
 689 /* Dynamic field arguments */
 690
 691 #define side_arg_dynamic_null(_attr) \
 692         { \
 693                 .dynamic_type = SIDE_DYNAMIC_TYPE_NULL, \
 694                 .u = { \
 695                         .side_basic = { \
 696                                 .attr = _attr, \
 697                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 698                         }, \
 699                 }, \
 700         }
 701
 702 #define side_arg_dynamic_bool(_val, _attr) \
 703         { \
 704                 .dynamic_type = SIDE_DYNAMIC_TYPE_BOOL, \
 705                 .u = { \
 706                         .side_basic = { \
 707                                 .attr = _attr, \
 708                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 709                                 .u = { \
 710                                         .side_bool = !!(_val), \
 711                                 }, \
 712                         }, \
 713                 }, \
 714         }
 715
 716 #define side_arg_dynamic_u8(_val, _attr) \
 717         { \
 718                 .dynamic_type = SIDE_DYNAMIC_TYPE_U8, \
 719                 .u = { \
 720                         .side_basic = { \
 721                                 .attr = _attr, \
 722                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 723                                 .u = { \
 724                                         .side_u8 = (_val), \
 725                                 }, \
 726                         }, \
 727                 }, \
 728         }
 729 #define side_arg_dynamic_u16(_val, _attr) \
 730         { \
 731                 .dynamic_type = SIDE_DYNAMIC_TYPE_U16, \
 732                 .u = { \
 733                         .side_basic = { \
 734                                 .attr = _attr, \
 735                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 736                                 .u = { \
 737                                         .side_u16 = (_val), \
 738                                 }, \
 739                         }, \
 740                 }, \
 741         }
 742 #define side_arg_dynamic_u32(_val, _attr) \
 743         { \
 744                 .dynamic_type = SIDE_DYNAMIC_TYPE_U32, \
 745                 .u = { \
 746                         .side_basic = { \
 747                                 .attr = _attr, \
 748                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 749                                 .u = { \
 750                                         .side_u32 = (_val), \
 751                                 }, \
 752                         }, \
 753                 }, \
 754         }
 755 #define side_arg_dynamic_u64(_val, _attr) \
 756         { \
 757                 .dynamic_type = SIDE_DYNAMIC_TYPE_U64, \
 758                 .u = { \
 759                         .side_basic = { \
 760                                 .attr = _attr, \
 761                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 762                                 .u = { \
 763                                         .side_u64 = (_val), \
 764                                 }, \
 765                         }, \
 766                 }, \
 767         }
 768
 769 #define side_arg_dynamic_s8(_val, _attr) \
 770         { \
 771                 .dynamic_type = SIDE_DYNAMIC_TYPE_S8, \
 772                 .u = { \
 773                         .side_basic = { \
 774                                 .attr = _attr, \
 775                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 776                                 .u = { \
 777                                         .side_s8 = (_val), \
 778                                 }, \
 779                         }, \
 780                 }, \
 781         }
 782 #define side_arg_dynamic_s16(_val, _attr) \
 783         { \
 784                 .dynamic_type = SIDE_DYNAMIC_TYPE_S16, \
 785                 .u = { \
 786                         .side_basic = { \
 787                                 .attr = _attr, \
 788                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 789                                 .u = { \
 790                                         .side_s16 = (_val), \
 791                                 }, \
 792                         }, \
 793                 }, \
 794         }
 795 #define side_arg_dynamic_s32(_val, _attr) \
 796         { \
 797                 .dynamic_type = SIDE_DYNAMIC_TYPE_S32, \
 798                 .u = { \
 799                         .side_basic = { \
 800                                 .attr = _attr, \
 801                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 802                                 .u = { \
 803                                         .side_s32 = (_val), \
 804                                 }, \
 805                         }, \
 806                 }, \
 807         }
 808 #define side_arg_dynamic_s64(_val, _attr) \
 809         { \
 810                 .dynamic_type = SIDE_DYNAMIC_TYPE_S64, \
 811                 .u = { \
 812                         .side_basic = { \
 813                                 .attr = _attr, \
 814                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 815                                 .u = { \
 816                                         .side_s64 = (_val), \
 817                                 }, \
 818                         }, \
 819                 }, \
 820         }
 821 #define side_arg_dynamic_byte(_val, _attr) \
 822         { \
 823                 .dynamic_type = SIDE_DYNAMIC_TYPE_BYTE, \
 824                 .u = { \
 825                         .side_basic = { \
 826                                 .attr = _attr, \
 827                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 828                                 .u = { \
 829                                         .side_byte = (_val), \
 830                                 }, \
 831                         }, \
 832                 }, \
 833         }
 834
 835 #define side_arg_dynamic_float_binary16(_val, _attr) \
 836         { \
 837                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, \
 838                 .u = { \
 839                         .side_basic = { \
 840                                 .attr = _attr, \
 841                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 842                                 .u = { \
 843                                         .side_float_binary16 = (_val), \
 844                                 }, \
 845                         }, \
 846                 }, \
 847         }
 848 #define side_arg_dynamic_float_binary32(_val, _attr) \
 849         { \
 850                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY32, \
 851                 .u = { \
 852                         .side_basic = { \
 853                                 .attr = _attr, \
 854                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 855                                 .u = { \
 856                                         .side_float_binary32 = (_val), \
 857                                 }, \
 858                         }, \
 859                 }, \
 860         }
 861 #define side_arg_dynamic_float_binary64(_val, _attr) \
 862         { \
 863                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY64, \
 864                 .u = { \
 865                         .side_basic = { \
 866                                 .attr = _attr, \
 867                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 868                                 .u = { \
 869                                         .side_float_binary64 = (_val), \
 870                                 }, \
 871                         }, \
 872                 }, \
 873         }
 874 #define side_arg_dynamic_float_binary128(_val, _attr) \
 875         { \
 876                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY128, \
 877                 .u = { \
 878                         .side_basic = { \
 879                                 .attr = _attr, \
 880                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 881                                 .u = { \
 882                                         .side_float_binary128 = (_val), \
 883                                 }, \
 884                         }, \
 885                 }, \
 886         }
 887
 888 #define side_arg_dynamic_string(_val, _attr) \
 889         { \
 890                 .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
 891                 .u = { \
 892                         .side_basic = { \
 893                                 .attr = _attr, \
 894                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 895                                 .u = { \
 896                                         .string = (_val), \
 897                                 }, \
 898                         }, \
 899                 }, \
 900         }
 901
 902 #define side_arg_dynamic_vla(_vla) \
 903         { \
 904                 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA, \
 905                 .u = { \
 906                         .side_dynamic_vla = (_vla), \
 907                 }, \
 908         }
 909
 910 #define side_arg_dynamic_vla_visitor(_dynamic_vla_visitor, _ctx, _attr) \
 911         { \
 912                 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA_VISITOR, \
 913                 .u = { \
 914                         .side_dynamic_vla_visitor = { \
 915                                 .app_ctx = _ctx, \
 916                                 .visitor = _dynamic_vla_visitor, \
 917                                 .attr = _attr, \
 918                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 919                         }, \
 920                 }, \
 921         }
 922
 923 #define side_arg_dynamic_struct(_struct) \
 924         { \
 925                 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT, \
 926                 .u = { \
 927                         .side_dynamic_struct = (_struct), \
 928                 }, \
 929         }
 930
 931 #define side_arg_dynamic_struct_visitor(_dynamic_struct_visitor, _ctx, _attr) \
 932         { \
 933                 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT_VISITOR, \
 934                 .u = { \
 935                         .side_dynamic_struct_visitor = { \
 936                                 .app_ctx = _ctx, \
 937                                 .visitor = _dynamic_struct_visitor, \
 938                                 .attr = _attr, \
 939                                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 940                         }, \
 941                 }, \
 942         }
 943
 944 #define side_arg_dynamic_define_vec(_identifier, _sav, _attr) \
 945         const struct side_arg_dynamic_vec _identifier##_vec[] = { _sav }; \
 946         const struct side_arg_dynamic_vec_vla _identifier = { \
 947                 .sav = _identifier##_vec, \
 948                 .attr = _attr, \
 949                 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
 950                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 951         }
 952
 953 #define side_arg_dynamic_define_struct(_identifier, _struct_fields, _attr) \
 954         const struct side_arg_dynamic_event_field _identifier##_fields[] = { _struct_fields }; \
 955         const struct side_arg_dynamic_event_struct _identifier = { \
 956                 .fields = _identifier##_fields, \
 957                 .attr = _attr, \
 958                 .len = SIDE_ARRAY_SIZE(_identifier##_fields), \
 959                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 960         }
 961
 962 #define side_arg_define_vec(_identifier, _sav) \
 963         const struct side_arg_vec _identifier##_vec[] = { _sav }; \
 964         const struct side_arg_vec_description _identifier = { \
 965                 .sav = _identifier##_vec, \
 966                 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
 967         }
 968
 969 #define side_arg_dynamic_field(_name, _elem) \
 970         { \
 971                 .field_name = _name, \
 972                 .elem = _elem, \
 973         }
 974
 975 #define side_arg_list(...)      __VA_ARGS__
 976
 977 #define side_define_enum(_identifier, _mappings, _attr) \
 978         const struct side_enum_mappings _identifier = { \
 979                 .mappings = _mappings, \
 980                 .attr = _attr, \
 981                 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
 982                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 983         }
 984
 985 #define side_enum_mapping_list(...) \
 986         SIDE_COMPOUND_LITERAL(const struct side_enum_mapping, __VA_ARGS__)
 987
 988 #define side_enum_mapping_range(_label, _begin, _end) \
 989         { \
 990                 .range_begin = _begin, \
 991                 .range_end = _end, \
 992                 .label = _label, \
 993         }
 994
 995 #define side_enum_mapping_value(_label, _value) \
 996         { \
 997                 .range_begin = _value, \
 998                 .range_end = _value, \
 999                 .label = _label, \
1000         }
1001
1002 #define side_define_enum_bitmap(_identifier, _mappings, _attr) \
1003         const struct side_enum_bitmap_mappings _identifier = { \
1004                 .mappings = _mappings, \
1005                 .attr = _attr, \
1006                 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
1007                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1008         }
1009
1010 #define side_enum_bitmap_mapping_list(...) \
1011         SIDE_COMPOUND_LITERAL(const struct side_enum_bitmap_mapping, __VA_ARGS__)
1012
1013 #define side_enum_bitmap_mapping_range(_label, _begin, _end) \
1014         { \
1015                 .range_begin = _begin, \
1016                 .range_end = _end, \
1017                 .label = _label, \
1018         }
1019
1020 #define side_enum_bitmap_mapping_value(_label, _value) \
1021         { \
1022                 .range_begin = _value, \
1023                 .range_end = _value, \
1024                 .label = _label, \
1025         }
1026
1027 #define side_event_cond(_identifier) \
1028         if (side_unlikely(__atomic_load_n(&side_event_enable__##_identifier, \
1029                                         __ATOMIC_RELAXED)))
1030
1031 #define side_event_call(_identifier, _sav) \
1032         { \
1033                 const struct side_arg_vec side_sav[] = { _sav }; \
1034                 const struct side_arg_vec_description sav_desc = { \
1035                         .sav = side_sav, \
1036                         .len = SIDE_ARRAY_SIZE(side_sav), \
1037                 }; \
1038                 side_call(&(_identifier), &sav_desc); \
1039         }
1040
1041 #define side_event(_identifier, _sav) \
1042         side_event_cond(_identifier) \
1043                 side_event_call(_identifier, SIDE_PARAM(_sav))
1044
1045 #define side_event_call_variadic(_identifier, _sav, _var_fields, _attr) \
1046         { \
1047                 const struct side_arg_vec side_sav[] = { _sav }; \
1048                 const struct side_arg_vec_description sav_desc = { \
1049                         .sav = side_sav, \
1050                         .len = SIDE_ARRAY_SIZE(side_sav), \
1051                 }; \
1052                 const struct side_arg_dynamic_event_field side_fields[] = { _var_fields }; \
1053                 const struct side_arg_dynamic_event_struct var_struct = { \
1054                         .fields = side_fields, \
1055                         .attr = _attr, \
1056                         .len = SIDE_ARRAY_SIZE(side_fields), \
1057                         .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1058                 }; \
1059                 side_call_variadic(&(_identifier), &sav_desc, &var_struct); \
1060         }
1061
1062 #define side_event_variadic(_identifier, _sav, _var, _attr) \
1063         side_event_cond(_identifier) \
1064                 side_event_call_variadic(_identifier, SIDE_PARAM(_sav), SIDE_PARAM(_var), SIDE_PARAM(_attr))
1065
1066 #define _side_define_event(_linkage, _identifier, _provider, _event, _loglevel, _fields, _attr, _flags) \
1067         _linkage uint32_t side_event_enable__##_identifier __attribute__((section("side_event_enable"))); \
1068         _linkage struct side_event_description __attribute__((section("side_event_description"))) \
1069                         _identifier = { \
1070                 .version = 0, \
1071                 .enabled = &(side_event_enable__##_identifier), \
1072                 .loglevel = _loglevel, \
1073                 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
1074                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1075                 ._unused = 0, \
1076                 .flags = (_flags), \
1077                 .provider_name = _provider, \
1078                 .event_name = _event, \
1079                 .fields = _fields, \
1080                 .attr = _attr, \
1081                 .callbacks = &side_empty_callback, \
1082         }; \
1083         static const struct side_event_description *side_event_ptr__##_identifier \
1084                 __attribute__((section("side_event_description_ptr"), used)) = &(_identifier);
1085
1086 #define side_static_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1087         _side_define_event(static, _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1088                         SIDE_PARAM(_attr), 0)
1089
1090 #define side_static_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1091         _side_define_event(static, _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1092                         SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
1093
1094 #define side_hidden_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1095         _side_define_event(__attribute__((visibility("hidden"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1096                         SIDE_PARAM(_attr), 0)
1097
1098 #define side_hidden_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1099         _side_define_event(__attribute__((visibility("hidden"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1100                         SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
1101
1102 #define side_export_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1103         _side_define_event(__attribute__((visibility("default"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1104                         SIDE_PARAM(_attr), 0)
1105
1106 #define side_export_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1107         _side_define_event(__attribute__((visibility("default"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1108                         SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
1109
1110 #define side_declare_event(_identifier) \
1111         extern uint32_t side_event_enable_##_identifier; \
1112         extern struct side_event_description _identifier
1113
1114 extern const struct side_callback side_empty_callback;
1115
1116 void side_call(const struct side_event_description *desc,
1117         const struct side_arg_vec_description *sav_desc);
1118 void side_call_variadic(const struct side_event_description *desc,
1119         const struct side_arg_vec_description *sav_desc,
1120         const struct side_arg_dynamic_event_struct *var_struct);
1121
1122 int side_tracer_callback_register(struct side_event_description *desc,
1123                 void (*call)(const struct side_event_description *desc,
1124                         const struct side_arg_vec_description *sav_desc,
1125                         void *priv),
1126                 void *priv);
1127 int side_tracer_callback_variadic_register(struct side_event_description *desc,
1128                 void (*call_variadic)(const struct side_event_description *desc,
1129                         const struct side_arg_vec_description *sav_desc,
1130                         const struct side_arg_dynamic_event_struct *var_struct,
1131                         void *priv),
1132                 void *priv);
1133 int side_tracer_callback_unregister(struct side_event_description *desc,
1134                 void (*call)(const struct side_event_description *desc,
1135                         const struct side_arg_vec_description *sav_desc,
1136                         void *priv),
1137                 void *priv);
1138 int side_tracer_callback_variadic_unregister(struct side_event_description *desc,
1139                 void (*call_variadic)(const struct side_event_description *desc,
1140                         const struct side_arg_vec_description *sav_desc,
1141                         const struct side_arg_dynamic_event_struct *var_struct,
1142                         void *priv),
1143                 void *priv);
1144
1145 #endif /* _SIDE_TRACE_H */