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
  32 enum side_type {
  33         SIDE_TYPE_BOOL,
  34
  35         SIDE_TYPE_U8,
  36         SIDE_TYPE_U16,
  37         SIDE_TYPE_U32,
  38         SIDE_TYPE_U64,
  39         SIDE_TYPE_S8,
  40         SIDE_TYPE_S16,
  41         SIDE_TYPE_S32,
  42         SIDE_TYPE_S64,
  43         SIDE_TYPE_BLOB,
  44
  45         SIDE_TYPE_ENUM_U8,
  46         SIDE_TYPE_ENUM_U16,
  47         SIDE_TYPE_ENUM_U32,
  48         SIDE_TYPE_ENUM_U64,
  49         SIDE_TYPE_ENUM_S8,
  50         SIDE_TYPE_ENUM_S16,
  51         SIDE_TYPE_ENUM_S32,
  52         SIDE_TYPE_ENUM_S64,
  53
  54         SIDE_TYPE_ENUM_BITMAP8,
  55         SIDE_TYPE_ENUM_BITMAP16,
  56         SIDE_TYPE_ENUM_BITMAP32,
  57         SIDE_TYPE_ENUM_BITMAP64,
  58
  59         SIDE_TYPE_FLOAT_BINARY16,
  60         SIDE_TYPE_FLOAT_BINARY32,
  61         SIDE_TYPE_FLOAT_BINARY64,
  62         SIDE_TYPE_FLOAT_BINARY128,
  63
  64         SIDE_TYPE_STRING,
  65
  66         SIDE_TYPE_STRUCT,
  67         SIDE_TYPE_ARRAY,
  68         SIDE_TYPE_VLA,
  69         SIDE_TYPE_VLA_VISITOR,
  70
  71         SIDE_TYPE_ARRAY_U8,
  72         SIDE_TYPE_ARRAY_U16,
  73         SIDE_TYPE_ARRAY_U32,
  74         SIDE_TYPE_ARRAY_U64,
  75         SIDE_TYPE_ARRAY_S8,
  76         SIDE_TYPE_ARRAY_S16,
  77         SIDE_TYPE_ARRAY_S32,
  78         SIDE_TYPE_ARRAY_S64,
  79         SIDE_TYPE_ARRAY_BLOB,
  80
  81         SIDE_TYPE_VLA_U8,
  82         SIDE_TYPE_VLA_U16,
  83         SIDE_TYPE_VLA_U32,
  84         SIDE_TYPE_VLA_U64,
  85         SIDE_TYPE_VLA_S8,
  86         SIDE_TYPE_VLA_S16,
  87         SIDE_TYPE_VLA_S32,
  88         SIDE_TYPE_VLA_S64,
  89         SIDE_TYPE_VLA_BLOB,
  90
  91         SIDE_TYPE_DYNAMIC,
  92 };
  93
  94 enum side_dynamic_type {
  95         SIDE_DYNAMIC_TYPE_NULL,
  96
  97         SIDE_DYNAMIC_TYPE_BOOL,
  98
  99         SIDE_DYNAMIC_TYPE_U8,
 100         SIDE_DYNAMIC_TYPE_U16,
 101         SIDE_DYNAMIC_TYPE_U32,
 102         SIDE_DYNAMIC_TYPE_U64,
 103         SIDE_DYNAMIC_TYPE_S8,
 104         SIDE_DYNAMIC_TYPE_S16,
 105         SIDE_DYNAMIC_TYPE_S32,
 106         SIDE_DYNAMIC_TYPE_S64,
 107
 108         SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
 109         SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
 110         SIDE_DYNAMIC_TYPE_FLOAT_BINARY64,
 111         SIDE_DYNAMIC_TYPE_FLOAT_BINARY128,
 112
 113         SIDE_DYNAMIC_TYPE_STRING,
 114
 115         SIDE_DYNAMIC_TYPE_STRUCT,
 116         SIDE_DYNAMIC_TYPE_STRUCT_VISITOR,
 117
 118         SIDE_DYNAMIC_TYPE_VLA,
 119         SIDE_DYNAMIC_TYPE_VLA_VISITOR,
 120 };
 121
 122 enum side_attr_type {
 123         SIDE_ATTR_TYPE_BOOL,
 124
 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
 134         SIDE_ATTR_TYPE_FLOAT_BINARY16,
 135         SIDE_ATTR_TYPE_FLOAT_BINARY32,
 136         SIDE_ATTR_TYPE_FLOAT_BINARY64,
 137         SIDE_ATTR_TYPE_FLOAT_BINARY128,
 138
 139         SIDE_ATTR_TYPE_STRING,
 140 };
 141
 142 enum side_loglevel {
 143         SIDE_LOGLEVEL_EMERG = 0,
 144         SIDE_LOGLEVEL_ALERT = 1,
 145         SIDE_LOGLEVEL_CRIT = 2,
 146         SIDE_LOGLEVEL_ERR = 3,
 147         SIDE_LOGLEVEL_WARNING = 4,
 148         SIDE_LOGLEVEL_NOTICE = 5,
 149         SIDE_LOGLEVEL_INFO = 6,
 150         SIDE_LOGLEVEL_DEBUG = 7,
 151 };
 152
 153 enum side_visitor_status {
 154         SIDE_VISITOR_STATUS_OK = 0,
 155         SIDE_VISITOR_STATUS_ERROR = -1,
 156 };
 157
 158 typedef enum side_visitor_status (*side_visitor)(
 159                 const struct side_tracer_visitor_ctx *tracer_ctx,
 160                 void *app_ctx);
 161 typedef enum side_visitor_status (*side_dynamic_struct_visitor)(
 162                 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
 163                 void *app_ctx);
 164 typedef enum side_visitor_status (*side_dynamic_vla_visitor)(
 165                 const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
 166                 void *app_ctx);
 167
 168 struct side_attr_value {
 169         uint32_t type;  /* enum side_attr_type */
 170         union {
 171                 uint8_t side_bool;
 172
 173                 uint8_t side_u8;
 174                 uint16_t side_u16;
 175                 uint32_t side_u32;
 176                 uint64_t side_u64;
 177                 int8_t side_s8;
 178                 int16_t side_s16;
 179                 int32_t side_s32;
 180                 int64_t side_s64;
 181
 182 #if __HAVE_FLOAT16
 183                 _Float16 side_float_binary16;
 184 #endif
 185 #if __HAVE_FLOAT32
 186                 _Float32 side_float_binary32;
 187 #endif
 188 #if __HAVE_FLOAT64
 189                 _Float64 side_float_binary64;
 190 #endif
 191 #if __HAVE_FLOAT128
 192                 _Float128 side_float_binary128;
 193 #endif
 194
 195                 const char *string;
 196         } u;
 197 };
 198
 199 /* User attributes. */
 200 struct side_attr {
 201         const char *key;
 202         const struct side_attr_value value;
 203 };
 204
 205 struct side_enum_mapping {
 206         int64_t range_begin;
 207         int64_t range_end;
 208         const char *label;
 209 };
 210
 211 struct side_enum_mappings {
 212         const struct side_enum_mapping *mappings;
 213         uint32_t nr_mappings;
 214 };
 215
 216 struct side_enum_bitmap_mapping {
 217         int64_t range_begin;
 218         int64_t range_end;
 219         const char *label;
 220 };
 221
 222 struct side_enum_bitmap_mappings {
 223         const struct side_enum_bitmap_mapping *mappings;
 224         uint32_t nr_mappings;
 225 };
 226
 227 struct side_type_description {
 228         uint32_t type;  /* enum side_type */
 229         uint32_t nr_attr;
 230         const struct side_attr *attr;
 231         union {
 232                 struct {
 233                         uint32_t nr_fields;
 234                         const struct side_event_field *fields;
 235                 } side_struct;
 236                 struct {
 237                         uint32_t length;
 238                         const struct side_type_description *elem_type;
 239                 } side_array;
 240                 struct {
 241                         const struct side_type_description *elem_type;
 242                 } side_vla;
 243                 struct {
 244                         const struct side_type_description *elem_type;
 245                         side_visitor visitor;
 246                 } side_vla_visitor;
 247                 const struct side_enum_mappings *side_enum_mappings;
 248                 const struct side_enum_bitmap_mappings *side_enum_bitmap_mappings;
 249         } u;
 250 };
 251
 252 struct side_event_field {
 253         const char *field_name;
 254         struct side_type_description side_type;
 255 };
 256
 257 enum side_event_flags {
 258         SIDE_EVENT_FLAG_VARIADIC = (1 << 0),
 259 };
 260
 261 struct side_event_description {
 262         uint32_t version;
 263         uint32_t enabled;
 264         uint32_t loglevel;      /* enum side_loglevel */
 265         uint32_t nr_fields;
 266         uint32_t nr_attr;
 267         uint32_t _unused;
 268         uint64_t flags;
 269         const char *provider_name;
 270         const char *event_name;
 271         const struct side_event_field *fields;
 272         const struct side_attr *attr;
 273 };
 274
 275 struct side_arg_dynamic_vec_vla {
 276         const struct side_arg_dynamic_vec *sav;
 277         uint32_t len;
 278 };
 279
 280 struct side_arg_dynamic_vec {
 281         uint32_t dynamic_type;  /* enum side_dynamic_type */
 282         uint32_t nr_attr;
 283         const struct side_attr *attr;
 284         union {
 285                 uint8_t side_bool;
 286
 287                 uint8_t side_u8;
 288                 uint16_t side_u16;
 289                 uint32_t side_u32;
 290                 uint64_t side_u64;
 291                 int8_t side_s8;
 292                 int16_t side_s16;
 293                 int32_t side_s32;
 294                 int64_t side_s64;
 295
 296 #if __HAVE_FLOAT16
 297                 _Float16 side_float_binary16;
 298 #endif
 299 #if __HAVE_FLOAT32
 300                 _Float32 side_float_binary32;
 301 #endif
 302 #if __HAVE_FLOAT64
 303                 _Float64 side_float_binary64;
 304 #endif
 305 #if __HAVE_FLOAT128
 306                 _Float128 side_float_binary128;
 307 #endif
 308
 309                 const char *string;
 310
 311                 const struct side_arg_dynamic_event_struct *side_dynamic_struct;
 312                 struct {
 313                         void *app_ctx;
 314                         side_dynamic_struct_visitor visitor;
 315                 } side_dynamic_struct_visitor;
 316
 317                 const struct side_arg_dynamic_vec_vla *side_dynamic_vla;
 318                 struct {
 319                         void *app_ctx;
 320                         side_dynamic_vla_visitor visitor;
 321                 } side_dynamic_vla_visitor;
 322         } u;
 323 };
 324
 325 struct side_arg_dynamic_event_field {
 326         const char *field_name;
 327         const struct side_arg_dynamic_vec elem;
 328 };
 329
 330 struct side_arg_dynamic_event_struct {
 331         const struct side_arg_dynamic_event_field *fields;
 332         uint32_t len;
 333 };
 334
 335 struct side_arg_vec {
 336         enum side_type type;
 337         union {
 338                 uint8_t side_bool;
 339
 340                 uint8_t side_u8;
 341                 uint16_t side_u16;
 342                 uint32_t side_u32;
 343                 uint64_t side_u64;
 344                 int8_t side_s8;
 345                 int16_t side_s16;
 346                 int32_t side_s32;
 347                 int64_t side_s64;
 348                 uint8_t side_blob;
 349
 350 #if __HAVE_FLOAT16
 351                 _Float16 side_float_binary16;
 352 #endif
 353 #if __HAVE_FLOAT32
 354                 _Float32 side_float_binary32;
 355 #endif
 356 #if __HAVE_FLOAT64
 357                 _Float64 side_float_binary64;
 358 #endif
 359 #if __HAVE_FLOAT128
 360                 _Float128 side_float_binary128;
 361 #endif
 362
 363                 const char *string;
 364                 const struct side_arg_vec_description *side_struct;
 365                 const struct side_arg_vec_description *side_array;
 366                 const struct side_arg_vec_description *side_vla;
 367                 void *side_vla_app_visitor_ctx;
 368
 369                 void *side_array_fixint;
 370                 struct {
 371                         void *p;
 372                         uint32_t length;
 373                 } side_vla_fixint;
 374
 375                 struct side_arg_dynamic_vec dynamic;
 376         } u;
 377 };
 378
 379 struct side_arg_vec_description {
 380         const struct side_arg_vec *sav;
 381         uint32_t len;
 382 };
 383
 384 /* The visitor pattern is a double-dispatch visitor. */
 385 struct side_tracer_visitor_ctx {
 386         enum side_visitor_status (*write_elem)(
 387                         const struct side_tracer_visitor_ctx *tracer_ctx,
 388                         const struct side_arg_vec *elem);
 389         void *priv;             /* Private tracer context. */
 390 };
 391
 392 struct side_tracer_dynamic_struct_visitor_ctx {
 393         enum side_visitor_status (*write_field)(
 394                         const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
 395                         const struct side_arg_dynamic_event_field *dynamic_field);
 396         void *priv;             /* Private tracer context. */
 397 };
 398
 399 struct side_tracer_dynamic_vla_visitor_ctx {
 400         enum side_visitor_status (*write_elem)(
 401                         const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
 402                         const struct side_arg_dynamic_vec *elem);
 403         void *priv;             /* Private tracer context. */
 404 };
 405
 406 #define side_attr(_key, _value) \
 407         { \
 408                 .key = _key, \
 409                 .value = SIDE_PARAM(_value), \
 410         }
 411
 412 #define side_attr_list(...) \
 413         SIDE_COMPOUND_LITERAL(const struct side_attr, __VA_ARGS__)
 414
 415 #define _side_type(_type, _attr) \
 416         { \
 417                 .type = _type, \
 418                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 419                 .attr = _attr, \
 420         }
 421
 422 #define side_type_bool(_attr)                           _side_type(SIDE_TYPE_BOOL, SIDE_PARAM(_attr))
 423 #define side_type_u8(_attr)                             _side_type(SIDE_TYPE_U8, SIDE_PARAM(_attr))
 424 #define side_type_u16(_attr)                            _side_type(SIDE_TYPE_U16, SIDE_PARAM(_attr))
 425 #define side_type_u32(_attr)                            _side_type(SIDE_TYPE_U32, SIDE_PARAM(_attr))
 426 #define side_type_u64(_attr)                            _side_type(SIDE_TYPE_U64, SIDE_PARAM(_attr))
 427 #define side_type_s8(_attr)                             _side_type(SIDE_TYPE_S8, SIDE_PARAM(_attr))
 428 #define side_type_s16(_attr)                            _side_type(SIDE_TYPE_S16, SIDE_PARAM(_attr))
 429 #define side_type_s32(_attr)                            _side_type(SIDE_TYPE_S32, SIDE_PARAM(_attr))
 430 #define side_type_s64(_attr)                            _side_type(SIDE_TYPE_S64, SIDE_PARAM(_attr))
 431 #define side_type_blob(_attr)                           _side_type(SIDE_TYPE_BLOB, SIDE_PARAM(_attr))
 432 #define side_type_float_binary16(_attr)                 _side_type(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
 433 #define side_type_float_binary32(_attr)                 _side_type(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
 434 #define side_type_float_binary64(_attr)                 _side_type(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
 435 #define side_type_float_binary128(_attr)                _side_type(SIDE_TYPE_FLOAT_BINARY128, SIDE_PARAM(_attr))
 436 #define side_type_string(_attr)                         _side_type(SIDE_TYPE_STRING, SIDE_PARAM(_attr))
 437 #define side_type_dynamic(_attr)                        _side_type(SIDE_TYPE_DYNAMIC, SIDE_PARAM(_attr))
 438
 439 #define _side_field(_name, _type) \
 440         { \
 441                 .field_name = _name, \
 442                 .side_type = _type, \
 443         }
 444
 445 #define side_field_bool(_name, _attr)                   _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
 446 #define side_field_u8(_name, _attr)                     _side_field(_name, side_type_u8(SIDE_PARAM(_attr)))
 447 #define side_field_u16(_name, _attr)                    _side_field(_name, side_type_u16(SIDE_PARAM(_attr)))
 448 #define side_field_u32(_name, _attr)                    _side_field(_name, side_type_u32(SIDE_PARAM(_attr)))
 449 #define side_field_u64(_name, _attr)                    _side_field(_name, side_type_u64(SIDE_PARAM(_attr)))
 450 #define side_field_s8(_name, _attr)                     _side_field(_name, side_type_s8(SIDE_PARAM(_attr)))
 451 #define side_field_s16(_name, _attr)                    _side_field(_name, side_type_s16(SIDE_PARAM(_attr)))
 452 #define side_field_s32(_name, _attr)                    _side_field(_name, side_type_s32(SIDE_PARAM(_attr)))
 453 #define side_field_s64(_name, _attr)                    _side_field(_name, side_type_s64(SIDE_PARAM(_attr)))
 454 #define side_field_blob(_name, _attr)                   _side_field(_name, side_type_blob(SIDE_PARAM(_attr)))
 455 #define side_field_float_binary16(_name, _attr)         _side_field(_name, side_type_float_binary16(SIDE_PARAM(_attr)))
 456 #define side_field_float_binary32(_name, _attr)         _side_field(_name, side_type_float_binary32(SIDE_PARAM(_attr)))
 457 #define side_field_float_binary64(_name, _attr)         _side_field(_name, side_type_float_binary64(SIDE_PARAM(_attr)))
 458 #define side_field_float_binary128(_name, _attr)        _side_field(_name, side_type_float_binary128(SIDE_PARAM(_attr)))
 459 #define side_field_string(_name, _attr)                 _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
 460 #define side_field_dynamic(_name, _attr)                _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
 461
 462 #define side_type_enum(_type, _mappings, _attr) \
 463         { \
 464                 .type = _type, \
 465                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 466                 .attr = _attr, \
 467                 .u = { \
 468                         .side_enum_mappings = _mappings, \
 469                 }, \
 470         }
 471 #define _side_field_enum(_name, _type, _mappings, _attr) \
 472         _side_field(_name, side_type_enum(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)))
 473
 474 #define side_field_enum_u8(_name, _mappings, _attr) \
 475         _side_field_enum(_name, SIDE_TYPE_ENUM_U8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 476 #define side_field_enum_u16(_name, _mappings, _attr) \
 477         _side_field_enum(_name, SIDE_TYPE_ENUM_U16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 478 #define side_field_enum_u32(_name, _mappings, _attr) \
 479         _side_field_enum(_name, SIDE_TYPE_ENUM_U32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 480 #define side_field_enum_u64(_name, _mappings, _attr) \
 481         _side_field_enum(_name, SIDE_TYPE_ENUM_U64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 482 #define side_field_enum_s8(_name, _mappings, _attr) \
 483         _side_field_enum(_name, SIDE_TYPE_ENUM_S8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 484 #define side_field_enum_s16(_name, _mappings, _attr) \
 485         _side_field_enum(_name, SIDE_TYPE_ENUM_S16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 486 #define side_field_enum_s32(_name, _mappings, _attr) \
 487         _side_field_enum(_name, SIDE_TYPE_ENUM_S32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 488 #define side_field_enum_s64(_name, _mappings, _attr) \
 489         _side_field_enum(_name, SIDE_TYPE_ENUM_S64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 490
 491 #define side_type_enum_bitmap(_type, _mappings, _attr) \
 492         { \
 493                 .type = _type, \
 494                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 495                 .attr = _attr, \
 496                 .u = { \
 497                         .side_enum_bitmap_mappings = _mappings, \
 498                 }, \
 499         }
 500 #define _side_field_enum_bitmap(_name, _type, _mappings, _attr) \
 501         _side_field(_name, side_type_enum_bitmap(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)))
 502
 503 #define side_field_enum_bitmap8(_name, _mappings, _attr) \
 504         _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 505 #define side_field_enum_bitmap16(_name, _mappings, _attr) \
 506         _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 507 #define side_field_enum_bitmap32(_name, _mappings, _attr) \
 508         _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 509 #define side_field_enum_bitmap64(_name, _mappings, _attr) \
 510         _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 511
 512 #define side_type_struct(_fields, _attr) \
 513         { \
 514                 .type = SIDE_TYPE_STRUCT, \
 515                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 516                 .attr = _attr, \
 517                 .u = { \
 518                         .side_struct = { \
 519                                 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
 520                                 .fields = _fields, \
 521                         }, \
 522                 }, \
 523         }
 524 #define side_field_struct(_name, _fields, _attr) \
 525         _side_field(_name, side_type_struct(SIDE_PARAM(_fields), SIDE_PARAM(_attr)))
 526
 527 #define side_type_array(_elem_type, _length, _attr) \
 528         { \
 529                 .type = SIDE_TYPE_ARRAY, \
 530                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 531                 .attr = _attr, \
 532                 .u = { \
 533                         .side_array = { \
 534                                 .length = _length, \
 535                                 .elem_type = _elem_type, \
 536                         }, \
 537                 }, \
 538         }
 539 #define side_field_array(_name, _elem_type, _length, _attr) \
 540         _side_field(_name, side_type_array(SIDE_PARAM(_elem_type), _length, SIDE_PARAM(_attr)))
 541
 542 #define side_type_vla(_elem_type, _attr) \
 543         { \
 544                 .type = SIDE_TYPE_VLA, \
 545                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 546                 .attr = _attr, \
 547                 .u = { \
 548                         .side_vla = { \
 549                                 .elem_type = _elem_type, \
 550                         }, \
 551                 }, \
 552         }
 553 #define side_field_vla(_name, _elem_type, _attr) \
 554         _side_field(_name, side_type_vla(SIDE_PARAM(_elem_type), SIDE_PARAM(_attr)))
 555
 556 #define side_type_vla_visitor(_elem_type, _visitor, _attr) \
 557         { \
 558                 .type = SIDE_TYPE_VLA_VISITOR, \
 559                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 560                 .attr = _attr, \
 561                 .u = { \
 562                         .side_vla_visitor = { \
 563                                 .elem_type = SIDE_PARAM(_elem_type), \
 564                                 .visitor = _visitor, \
 565                         }, \
 566                 }, \
 567         }
 568 #define side_field_vla_visitor(_name, _elem_type, _visitor, _attr) \
 569         _side_field(_name, side_type_vla_visitor(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)))
 570
 571 #define side_elem(...) \
 572         SIDE_COMPOUND_LITERAL(const struct side_type_description, __VA_ARGS__)
 573
 574 #define side_field_list(...) \
 575         SIDE_COMPOUND_LITERAL(const struct side_event_field, __VA_ARGS__)
 576
 577 #define side_arg_bool(val)              { .type = SIDE_TYPE_BOOL, .u = { .side_bool = !!(val) } }
 578 #define side_arg_u8(val)                { .type = SIDE_TYPE_U8, .u = { .side_u8 = (val) } }
 579 #define side_arg_u16(val)               { .type = SIDE_TYPE_U16, .u = { .side_u16 = (val) } }
 580 #define side_arg_u32(val)               { .type = SIDE_TYPE_U32, .u = { .side_u32 = (val) } }
 581 #define side_arg_u64(val)               { .type = SIDE_TYPE_U64, .u = { .side_u64 = (val) } }
 582 #define side_arg_s8(val)                { .type = SIDE_TYPE_S8, .u = { .side_s8 = (val) } }
 583 #define side_arg_s16(val)               { .type = SIDE_TYPE_S16, .u = { .side_s16 = (val) } }
 584 #define side_arg_s32(val)               { .type = SIDE_TYPE_S32, .u = { .side_s32 = (val) } }
 585 #define side_arg_s64(val)               { .type = SIDE_TYPE_S64, .u = { .side_s64 = (val) } }
 586 #define side_arg_blob(val)              { .type = SIDE_TYPE_BLOB, .u = { .side_blob = (val) } }
 587 #define side_arg_enum_u8(val)           { .type = SIDE_TYPE_ENUM_U8, .u = { .side_u8 = (val) } }
 588 #define side_arg_enum_u16(val)          { .type = SIDE_TYPE_ENUM_U16, .u = { .side_u16 = (val) } }
 589 #define side_arg_enum_u32(val)          { .type = SIDE_TYPE_ENUM_U32, .u = { .side_u32 = (val) } }
 590 #define side_arg_enum_u64(val)          { .type = SIDE_TYPE_ENUM_U64, .u = { .side_u64 = (val) } }
 591 #define side_arg_enum_s8(val)           { .type = SIDE_TYPE_ENUM_S8, .u = { .side_s8 = (val) } }
 592 #define side_arg_enum_s16(val)          { .type = SIDE_TYPE_ENUM_S16, .u = { .side_s16 = (val) } }
 593 #define side_arg_enum_s32(val)          { .type = SIDE_TYPE_ENUM_S32, .u = { .side_s32 = (val) } }
 594 #define side_arg_enum_s64(val)          { .type = SIDE_TYPE_ENUM_S64, .u = { .side_s64 = (val) } }
 595 #define side_arg_enum_bitmap8(val)      { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .side_u8 = (val) } }
 596 #define side_arg_enum_bitmap16(val)     { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .side_u16 = (val) } }
 597 #define side_arg_enum_bitmap32(val)     { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .side_u32 = (val) } }
 598 #define side_arg_enum_bitmap64(val)     { .type = SIDE_TYPE_ENUM_BITMAP64, .u = { .side_u64 = (val) } }
 599 #define side_arg_float_binary16(val)    { .type = SIDE_TYPE_FLOAT_BINARY16, .u = { .side_float_binary16 = (val) } }
 600 #define side_arg_float_binary32(val)    { .type = SIDE_TYPE_FLOAT_BINARY32, .u = { .side_float_binary32 = (val) } }
 601 #define side_arg_float_binary64(val)    { .type = SIDE_TYPE_FLOAT_BINARY64, .u = { .side_float_binary64 = (val) } }
 602 #define side_arg_float_binary128(val)   { .type = SIDE_TYPE_FLOAT_BINARY128, .u = { .side_float_binary128 = (val) } }
 603
 604 #define side_arg_string(val)            { .type = SIDE_TYPE_STRING, .u = { .string = (val) } }
 605 #define side_arg_struct(_side_type)     { .type = SIDE_TYPE_STRUCT, .u = { .side_struct = (_side_type) } }
 606 #define side_arg_array(_side_type)      { .type = SIDE_TYPE_ARRAY, .u = { .side_array = (_side_type) } }
 607 #define side_arg_vla(_side_type)        { .type = SIDE_TYPE_VLA, .u = { .side_vla = (_side_type) } }
 608 #define side_arg_vla_visitor(_ctx)      { .type = SIDE_TYPE_VLA_VISITOR, .u = { .side_vla_app_visitor_ctx = (_ctx) } }
 609
 610 #define side_arg_array_u8(_ptr)         { .type = SIDE_TYPE_ARRAY_U8, .u = { .side_array_fixint = (_ptr) } }
 611 #define side_arg_array_u16(_ptr)        { .type = SIDE_TYPE_ARRAY_U16, .u = { .side_array_fixint = (_ptr) } }
 612 #define side_arg_array_u32(_ptr)        { .type = SIDE_TYPE_ARRAY_U32, .u = { .side_array_fixint = (_ptr) } }
 613 #define side_arg_array_u64(_ptr)        { .type = SIDE_TYPE_ARRAY_U64, .u = { .side_array_fixint = (_ptr) } }
 614 #define side_arg_array_s8(_ptr)         { .type = SIDE_TYPE_ARRAY_S8, .u = { .side_array_fixint = (_ptr) } }
 615 #define side_arg_array_s16(_ptr)        { .type = SIDE_TYPE_ARRAY_S16, .u = { .side_array_fixint  = (_ptr) } }
 616 #define side_arg_array_s32(_ptr)        { .type = SIDE_TYPE_ARRAY_S32, .u = { .side_array_fixint = (_ptr) } }
 617 #define side_arg_array_s64(_ptr)        { .type = SIDE_TYPE_ARRAY_S64, .u = { .side_array_fixint = (_ptr) } }
 618 #define side_arg_array_blob(_ptr)       { .type = SIDE_TYPE_ARRAY_BLOB, .u = { .side_array_fixint = (_ptr) } }
 619
 620 #define side_arg_vla_u8(_ptr, _length)  { .type = SIDE_TYPE_VLA_U8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } }
 621 #define side_arg_vla_u16(_ptr, _length) { .type = SIDE_TYPE_VLA_U16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 622 #define side_arg_vla_u32(_ptr, _length) { .type = SIDE_TYPE_VLA_U32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 623 #define side_arg_vla_u64(_ptr, _length) { .type = SIDE_TYPE_VLA_U64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 624 #define side_arg_vla_s8(_ptr, _length)  { .type = SIDE_TYPE_VLA_S8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 625 #define side_arg_vla_s16(_ptr, _length) { .type = SIDE_TYPE_VLA_S16, .u = { .side_vla_fixint  = { .p = (_ptr), .length = (_length) } } }
 626 #define side_arg_vla_s32(_ptr, _length) { .type = SIDE_TYPE_VLA_S32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 627 #define side_arg_vla_s64(_ptr, _length) { .type = SIDE_TYPE_VLA_S64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 628 #define side_arg_vla_blob(_ptr, _length) { .type = SIDE_TYPE_VLA_BLOB, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 629
 630 #define side_arg_dynamic(dynamic_arg_type) \
 631         { \
 632                 .type = SIDE_TYPE_DYNAMIC, \
 633                 .u = { \
 634                         .dynamic = dynamic_arg_type, \
 635                 }, \
 636         }
 637
 638 #define side_arg_dynamic_null(_attr) \
 639         { \
 640                 .dynamic_type = SIDE_DYNAMIC_TYPE_NULL, \
 641                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 642                 .attr = _attr, \
 643         }
 644
 645 #define side_arg_dynamic_bool(_val, _attr) \
 646         { \
 647                 .dynamic_type = SIDE_DYNAMIC_TYPE_BOOL, \
 648                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 649                 .attr = _attr, \
 650                 .u = { \
 651                         .side_bool = !!(_val), \
 652                 }, \
 653         }
 654
 655 #define side_arg_dynamic_u8(_val, _attr) \
 656         { \
 657                 .dynamic_type = SIDE_DYNAMIC_TYPE_U8, \
 658                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 659                 .attr = _attr, \
 660                 .u = { \
 661                         .side_u8 = (_val), \
 662                 }, \
 663         }
 664 #define side_arg_dynamic_u16(_val, _attr) \
 665         { \
 666                 .dynamic_type = SIDE_DYNAMIC_TYPE_U16, \
 667                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 668                 .attr = _attr, \
 669                 .u = { \
 670                         .side_u16 = (_val), \
 671                 }, \
 672         }
 673 #define side_arg_dynamic_u32(_val, _attr) \
 674         { \
 675                 .dynamic_type = SIDE_DYNAMIC_TYPE_U32, \
 676                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 677                 .attr = _attr, \
 678                 .u = { \
 679                         .side_u32 = (_val), \
 680                 }, \
 681         }
 682 #define side_arg_dynamic_u64(_val, _attr) \
 683         { \
 684                 .dynamic_type = SIDE_DYNAMIC_TYPE_U64, \
 685                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 686                 .attr = _attr, \
 687                 .u = { \
 688                         .side_u64 = (_val), \
 689                 }, \
 690         }
 691
 692 #define side_arg_dynamic_s8(_val, _attr) \
 693         { \
 694                 .dynamic_type = SIDE_DYNAMIC_TYPE_S8, \
 695                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 696                 .attr = _attr, \
 697                 .u = { \
 698                         .side_s8 = (_val), \
 699                 }, \
 700         }
 701 #define side_arg_dynamic_s16(_val, _attr) \
 702         { \
 703                 .dynamic_type = SIDE_DYNAMIC_TYPE_S16, \
 704                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 705                 .attr = _attr, \
 706                 .u = { \
 707                         .side_s16 = (_val), \
 708                 }, \
 709         }
 710 #define side_arg_dynamic_s32(_val, _attr) \
 711         { \
 712                 .dynamic_type = SIDE_DYNAMIC_TYPE_S32, \
 713                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 714                 .attr = _attr, \
 715                 .u = { \
 716                         .side_s32 = (_val), \
 717                 }, \
 718         }
 719 #define side_arg_dynamic_s64(_val, _attr) \
 720         { \
 721                 .dynamic_type = SIDE_DYNAMIC_TYPE_S64, \
 722                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 723                 .attr = _attr, \
 724                 .u = { \
 725                         .side_s64 = (_val), \
 726                 }, \
 727         }
 728
 729 #define side_arg_dynamic_float_binary16(_val, _attr) \
 730         { \
 731                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, \
 732                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 733                 .attr = _attr, \
 734                 .u = { \
 735                         .side_float_binary16 = (_val), \
 736                 }, \
 737         }
 738 #define side_arg_dynamic_float_binary32(_val, _attr) \
 739         { \
 740                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY32, \
 741                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 742                 .attr = _attr, \
 743                 .u = { \
 744                         .side_float_binary32 = (_val), \
 745                 }, \
 746         }
 747 #define side_arg_dynamic_float_binary64(_val, _attr) \
 748         { \
 749                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY64, \
 750                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 751                 .attr = _attr, \
 752                 .u = { \
 753                         .side_float_binary64 = (_val), \
 754                 }, \
 755         }
 756 #define side_arg_dynamic_float_binary128(_val, _attr) \
 757         { \
 758                 .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY128, \
 759                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 760                 .attr = _attr, \
 761                 .u = { \
 762                         .side_float_binary128 = (_val), \
 763                 }, \
 764         }
 765
 766 #define side_arg_dynamic_string(_val, _attr) \
 767         { \
 768                 .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
 769                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 770                 .attr = _attr, \
 771                 .u = { \
 772                         .string = (_val), \
 773                 }, \
 774         }
 775
 776 #define side_arg_dynamic_vla(_vla, _attr) \
 777         { \
 778                 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA, \
 779                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 780                 .attr = _attr, \
 781                 .u = { \
 782                         .side_dynamic_vla = (_vla), \
 783                 }, \
 784         }
 785
 786 #define side_arg_dynamic_vla_visitor(_dynamic_vla_visitor, _ctx, _attr) \
 787         { \
 788                 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA_VISITOR, \
 789                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 790                 .attr = _attr, \
 791                 .u = { \
 792                         .side_dynamic_vla_visitor = { \
 793                                 .app_ctx = _ctx, \
 794                                 .visitor = _dynamic_vla_visitor, \
 795                         }, \
 796                 }, \
 797         }
 798
 799 #define side_arg_dynamic_struct(_struct, _attr) \
 800         { \
 801                 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT, \
 802                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 803                 .attr = _attr, \
 804                 .u = { \
 805                         .side_dynamic_struct = (_struct), \
 806                 }, \
 807         }
 808
 809 #define side_arg_dynamic_struct_visitor(_dynamic_struct_visitor, _ctx, _attr) \
 810         { \
 811                 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT_VISITOR, \
 812                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 813                 .attr = _attr, \
 814                 .u = { \
 815                         .side_dynamic_struct_visitor = { \
 816                                 .app_ctx = _ctx, \
 817                                 .visitor = _dynamic_struct_visitor, \
 818                         }, \
 819                 }, \
 820         }
 821
 822 #define side_arg_dynamic_define_vec(_identifier, _sav) \
 823         const struct side_arg_dynamic_vec _identifier##_vec[] = { _sav }; \
 824         const struct side_arg_dynamic_vec_vla _identifier = { \
 825                 .sav = _identifier##_vec, \
 826                 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
 827         }
 828
 829 #define side_arg_dynamic_define_struct(_identifier, _struct_fields) \
 830         const struct side_arg_dynamic_event_field _identifier##_fields[] = { _struct_fields }; \
 831         const struct side_arg_dynamic_event_struct _identifier = { \
 832                 .fields = _identifier##_fields, \
 833                 .len = SIDE_ARRAY_SIZE(_identifier##_fields), \
 834         }
 835
 836 #define side_arg_define_vec(_identifier, _sav) \
 837         const struct side_arg_vec _identifier##_vec[] = { _sav }; \
 838         const struct side_arg_vec_description _identifier = { \
 839                 .sav = _identifier##_vec, \
 840                 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
 841         }
 842
 843 #define side_arg_dynamic_field(_name, _elem) \
 844         { \
 845                 .field_name = _name, \
 846                 .elem = _elem, \
 847         }
 848
 849 #define side_arg_list(...)      __VA_ARGS__
 850
 851 #define side_attr_bool(val)             { .type = SIDE_ATTR_TYPE_BOOL, .u = { .side_bool = !!(val) } }
 852 #define side_attr_u8(val)               { .type = SIDE_ATTR_TYPE_U8, .u = { .side_u8 = (val) } }
 853 #define side_attr_u16(val)              { .type = SIDE_ATTR_TYPE_U16, .u = { .side_u16 = (val) } }
 854 #define side_attr_u32(val)              { .type = SIDE_ATTR_TYPE_U32, .u = { .side_u32 = (val) } }
 855 #define side_attr_u64(val)              { .type = SIDE_ATTR_TYPE_U64, .u = { .side_u64 = (val) } }
 856 #define side_attr_s8(val)               { .type = SIDE_ATTR_TYPE_S8, .u = { .side_s8 = (val) } }
 857 #define side_attr_s16(val)              { .type = SIDE_ATTR_TYPE_S16, .u = { .side_s16 = (val) } }
 858 #define side_attr_s32(val)              { .type = SIDE_ATTR_TYPE_S32, .u = { .side_s32 = (val) } }
 859 #define side_attr_s64(val)              { .type = SIDE_ATTR_TYPE_S64, .u = { .side_s64 = (val) } }
 860 #define side_attr_float_binary16(val)   { .type = SIDE_ATTR_TYPE_FLOAT_BINARY16, .u = { .side_float_binary16 = (val) } }
 861 #define side_attr_float_binary32(val)   { .type = SIDE_ATTR_TYPE_FLOAT_BINARY32, .u = { .side_float_binary32 = (val) } }
 862 #define side_attr_float_binary64(val)   { .type = SIDE_ATTR_TYPE_FLOAT_BINARY64, .u = { .side_float_binary64 = (val) } }
 863 #define side_attr_float_binary128(val)  { .type = SIDE_ATTR_TYPE_FLOAT_BINARY128, .u = { .side_float_binary128 = (val) } }
 864 #define side_attr_string(val)           { .type = SIDE_ATTR_TYPE_STRING, .u = { .string = (val) } }
 865
 866 #define side_event_cond(desc) if (side_unlikely((desc)->enabled))
 867
 868 #define side_event_call(desc, _sav) \
 869         { \
 870                 const struct side_arg_vec side_sav[] = { _sav }; \
 871                 const struct side_arg_vec_description sav_desc = { \
 872                         .sav = side_sav, \
 873                         .len = SIDE_ARRAY_SIZE(side_sav), \
 874                 }; \
 875                 side_call(desc, &sav_desc); \
 876         }
 877
 878 #define side_event(desc, sav) \
 879         side_event_cond(desc) \
 880                 side_event_call(desc, SIDE_PARAM(sav))
 881
 882 #define side_event_call_variadic(desc, _sav, _var_fields) \
 883         { \
 884                 const struct side_arg_vec side_sav[] = { _sav }; \
 885                 const struct side_arg_vec_description sav_desc = { \
 886                         .sav = side_sav, \
 887                         .len = SIDE_ARRAY_SIZE(side_sav), \
 888                 }; \
 889                 const struct side_arg_dynamic_event_field side_fields[] = { _var_fields }; \
 890                 const struct side_arg_dynamic_event_struct var_struct = { \
 891                         .fields = side_fields, \
 892                         .len = SIDE_ARRAY_SIZE(side_fields), \
 893                 }; \
 894                 side_call_variadic(desc, &sav_desc, &var_struct); \
 895         }
 896
 897 #define side_event_variadic(desc, sav, var) \
 898         side_event_cond(desc) \
 899                 side_event_call_variadic(desc, SIDE_PARAM(sav), SIDE_PARAM(var))
 900
 901 #define side_define_enum(_identifier, _mappings) \
 902         const struct side_enum_mappings _identifier = { \
 903                 .mappings = _mappings, \
 904                 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
 905         }
 906
 907 #define side_enum_mapping_list(...) \
 908         SIDE_COMPOUND_LITERAL(const struct side_enum_mapping, __VA_ARGS__)
 909
 910 #define side_enum_mapping_range(_label, _begin, _end) \
 911         { \
 912                 .range_begin = _begin, \
 913                 .range_end = _end, \
 914                 .label = _label, \
 915         }
 916
 917 #define side_enum_mapping_value(_label, _value) \
 918         { \
 919                 .range_begin = _value, \
 920                 .range_end = _value, \
 921                 .label = _label, \
 922         }
 923
 924 #define side_define_enum_bitmap(_identifier, _mappings) \
 925         const struct side_enum_bitmap_mappings _identifier = { \
 926                 .mappings = _mappings, \
 927                 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
 928         }
 929
 930 #define side_enum_bitmap_mapping_list(...) \
 931         SIDE_COMPOUND_LITERAL(const struct side_enum_bitmap_mapping, __VA_ARGS__)
 932
 933 #define side_enum_bitmap_mapping_range(_label, _begin, _end) \
 934         { \
 935                 .range_begin = _begin, \
 936                 .range_end = _end, \
 937                 .label = _label, \
 938         }
 939
 940 #define side_enum_bitmap_mapping_value(_label, _value) \
 941         { \
 942                 .range_begin = _value, \
 943                 .range_end = _value, \
 944                 .label = _label, \
 945         }
 946
 947 #define _side_define_event(_identifier, _provider, _event, _loglevel, _fields, _attr, _flags) \
 948         struct side_event_description _identifier = { \
 949                 .version = 0, \
 950                 .enabled = 0, \
 951                 .loglevel = _loglevel, \
 952                 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
 953                 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
 954                 .flags = (_flags), \
 955                 .provider_name = _provider, \
 956                 .event_name = _event, \
 957                 .fields = _fields, \
 958                 .attr = _attr, \
 959         }
 960
 961 #define side_define_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
 962         _side_define_event(_identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
 963                         SIDE_PARAM(_attr), 0)
 964
 965 #define side_define_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
 966         _side_define_event(_identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
 967                         SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
 968
 969 #define side_declare_event(_identifier) \
 970         struct side_event_description _identifier
 971
 972 void side_call(const struct side_event_description *desc,
 973         const struct side_arg_vec_description *sav_desc);
 974 void side_call_variadic(const struct side_event_description *desc,
 975         const struct side_arg_vec_description *sav_desc,
 976         const struct side_arg_dynamic_event_struct *var_struct);
 977
 978 #endif /* _SIDE_TRACE_H */