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