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