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