projects / libside.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move type descriptions in header file
[libside.git] / include / side / trace.h
CommitLineData
f611d0c3
MD		 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>
fb25b355 13#include <math.h>
f611d0c3 14#include <side/macros.h>
8bdd5c12 15#include <side/endian.h>
f611d0c3
MD		 16
17/* SIDE stands for "Static Instrumentation Dynamically Enabled" */
18
64f5abc7
MD		 19//TODO: as those structures will be ABI, we need to either consider them
20//fixed forever, or think of a scheme that would allow their binary
07f35472 21//representation to be extended if need be.
64f5abc7 22
f611d0c3 23struct side_arg_vec;
a2e2357e
MD		 24struct side_arg_vec_description;
25struct side_arg_dynamic_vec;
26struct side_arg_dynamic_vec_vla;
f611d0c3
MD		 27struct side_type_description;
28struct side_event_field;
7a1cb105 29struct side_event_field_sg;
352a4b77 30struct side_tracer_visitor_ctx;
c208889e 31struct side_tracer_dynamic_struct_visitor_ctx;
bdc39c09 32struct side_tracer_dynamic_vla_visitor_ctx;
d89fabc8
MD		 33struct side_event_description;
34struct side_arg_dynamic_event_struct;
6e46f5e6 35struct side_events_register_handle;
f611d0c3
MD		 36
37enum side_type {
e24949fa 38 /* Basic types */
9b641221 39 SIDE_TYPE_NULL,
4f40d951 40 SIDE_TYPE_BOOL,
f611d0c3
MD		 41 SIDE_TYPE_U8,
42 SIDE_TYPE_U16,
43 SIDE_TYPE_U32,
44 SIDE_TYPE_U64,
45 SIDE_TYPE_S8,
46 SIDE_TYPE_S16,
47 SIDE_TYPE_S32,
48 SIDE_TYPE_S64,
f7653b43 49 SIDE_TYPE_BYTE,
dd6e76cb
MD		 50 SIDE_TYPE_POINTER32,
51 SIDE_TYPE_POINTER64,
e24949fa
MD		 52 SIDE_TYPE_FLOAT_BINARY16,
53 SIDE_TYPE_FLOAT_BINARY32,
54 SIDE_TYPE_FLOAT_BINARY64,
55 SIDE_TYPE_FLOAT_BINARY128,
56 SIDE_TYPE_STRING,
ba845af5 57
e24949fa 58 /* Compound types */
f611d0c3 59 SIDE_TYPE_STRUCT,
7a1cb105 60 SIDE_TYPE_STRUCT_SG,
f611d0c3
MD		 61 SIDE_TYPE_ARRAY,
62 SIDE_TYPE_VLA,
63 SIDE_TYPE_VLA_VISITOR,
ba845af5
MD		 64
65 SIDE_TYPE_ARRAY_U8,
66 SIDE_TYPE_ARRAY_U16,
67 SIDE_TYPE_ARRAY_U32,
68 SIDE_TYPE_ARRAY_U64,
69 SIDE_TYPE_ARRAY_S8,
70 SIDE_TYPE_ARRAY_S16,
71 SIDE_TYPE_ARRAY_S32,
72 SIDE_TYPE_ARRAY_S64,
f7653b43 73 SIDE_TYPE_ARRAY_BYTE,
dd6e76cb
MD		 74 SIDE_TYPE_ARRAY_POINTER32,
75 SIDE_TYPE_ARRAY_POINTER64,
ba845af5 76
1533629f
MD		 77 SIDE_TYPE_VLA_U8,
78 SIDE_TYPE_VLA_U16,
79 SIDE_TYPE_VLA_U32,
80 SIDE_TYPE_VLA_U64,
81 SIDE_TYPE_VLA_S8,
82 SIDE_TYPE_VLA_S16,
83 SIDE_TYPE_VLA_S32,
84 SIDE_TYPE_VLA_S64,
f7653b43 85 SIDE_TYPE_VLA_BYTE,
dd6e76cb
MD		 86 SIDE_TYPE_VLA_POINTER32,
87 SIDE_TYPE_VLA_POINTER64,
1533629f 88
af6aa6e1 89 /* Enumeration types */
d8be25de 90 SIDE_TYPE_ENUM,
bab5d6e4 91 SIDE_TYPE_ENUM_BITMAP,
af6aa6e1 92
e24949fa 93 /* Dynamic type */
bdc39c09
MD		 94 SIDE_TYPE_DYNAMIC,
95};
96
97enum side_dynamic_type {
e24949fa 98 /* Basic types */
bdc39c09 99 SIDE_DYNAMIC_TYPE_NULL,
4f40d951 100 SIDE_DYNAMIC_TYPE_BOOL,
bdc39c09
MD		 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,
f7653b43 109 SIDE_DYNAMIC_TYPE_BYTE,
dd6e76cb
MD		 110 SIDE_DYNAMIC_TYPE_POINTER32,
111 SIDE_DYNAMIC_TYPE_POINTER64,
fb25b355
MD		 112 SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
113 SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
114 SIDE_DYNAMIC_TYPE_FLOAT_BINARY64,
115 SIDE_DYNAMIC_TYPE_FLOAT_BINARY128,
bdc39c09
MD		 116 SIDE_DYNAMIC_TYPE_STRING,
117
e24949fa 118 /* Compound types */
c208889e
MD		 119 SIDE_DYNAMIC_TYPE_STRUCT,
120 SIDE_DYNAMIC_TYPE_STRUCT_VISITOR,
a2e2357e 121 SIDE_DYNAMIC_TYPE_VLA,
bdc39c09 122 SIDE_DYNAMIC_TYPE_VLA_VISITOR,
f611d0c3
MD		 123};
124
bc3c89b3 125enum side_attr_type {
e2c978ee 126 SIDE_ATTR_TYPE_NULL,
bc3c89b3 127 SIDE_ATTR_TYPE_BOOL,
bc3c89b3
MD		 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,
dd6e76cb
MD		 136 SIDE_ATTR_TYPE_POINTER32,
137 SIDE_ATTR_TYPE_POINTER64,
bc3c89b3
MD		 138 SIDE_ATTR_TYPE_FLOAT_BINARY16,
139 SIDE_ATTR_TYPE_FLOAT_BINARY32,
140 SIDE_ATTR_TYPE_FLOAT_BINARY64,
141 SIDE_ATTR_TYPE_FLOAT_BINARY128,
bc3c89b3
MD		 142 SIDE_ATTR_TYPE_STRING,
143};
144
7a1cb105 145enum side_type_sg {
9b641221 146 SIDE_TYPE_SG_NULL,
7a1cb105
MD		 147 SIDE_TYPE_SG_UNSIGNED_INT,
148 SIDE_TYPE_SG_SIGNED_INT,
149};
150
f611d0c3
MD		 151enum side_loglevel {
152 SIDE_LOGLEVEL_EMERG = 0,
153 SIDE_LOGLEVEL_ALERT = 1,
154 SIDE_LOGLEVEL_CRIT = 2,
155 SIDE_LOGLEVEL_ERR = 3,
156 SIDE_LOGLEVEL_WARNING = 4,
157 SIDE_LOGLEVEL_NOTICE = 5,
158 SIDE_LOGLEVEL_INFO = 6,
159 SIDE_LOGLEVEL_DEBUG = 7,
160};
161
162enum side_visitor_status {
f611d0c3 163 SIDE_VISITOR_STATUS_OK = 0,
db6ecef9 164 SIDE_VISITOR_STATUS_ERROR = -1,
f611d0c3
MD		 165};
166
a3f36db7
MD		 167enum side_error {
168 SIDE_ERROR_OK = 0,
169 SIDE_ERROR_INVAL = 1,
170 SIDE_ERROR_EXIST = 2,
171 SIDE_ERROR_NOMEM = 3,
172 SIDE_ERROR_NOENT = 4,
6e46f5e6 173 SIDE_ERROR_EXITING = 5,
a3f36db7
MD		 174};
175
8bdd5c12
MD		 176enum side_type_byte_order {
177 SIDE_TYPE_BYTE_ORDER_LE = 0,
178 SIDE_TYPE_BYTE_ORDER_BE = 1,
179};
180
181#if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
182# define SIDE_TYPE_BYTE_ORDER_HOST SIDE_TYPE_BYTE_ORDER_LE
183#else
184# define SIDE_TYPE_BYTE_ORDER_HOST SIDE_TYPE_BYTE_ORDER_BE
185#endif
186
187#if (SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN)
188# define SIDE_TYPE_FLOAT_WORD_ORDER_HOST SIDE_TYPE_BYTE_ORDER_LE
189#else
190# define SIDE_TYPE_FLOAT_WORD_ORDER_HOST SIDE_TYPE_BYTE_ORDER_BE
191#endif
192
f93e01ac
MD		 193typedef enum side_visitor_status (*side_visitor)(
194 const struct side_tracer_visitor_ctx *tracer_ctx,
195 void *app_ctx);
196typedef enum side_visitor_status (*side_dynamic_struct_visitor)(
197 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
198 void *app_ctx);
199typedef enum side_visitor_status (*side_dynamic_vla_visitor)(
200 const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
201 void *app_ctx);
f611d0c3 202
d37fe349 203union side_integer_value {
43d85239
MD		 204 uint8_t side_u8;
205 uint16_t side_u16;
206 uint32_t side_u32;
207 uint64_t side_u64;
208 int8_t side_s8;
209 int16_t side_s16;
210 int32_t side_s32;
211 int64_t side_s64;
de4ae6e8 212} SIDE_PACKED;
43d85239 213
d37fe349 214union side_float_value {
bc3c89b3
MD		 215#if __HAVE_FLOAT16
216 _Float16 side_float_binary16;
217#endif
218#if __HAVE_FLOAT32
219 _Float32 side_float_binary32;
220#endif
221#if __HAVE_FLOAT64
222 _Float64 side_float_binary64;
223#endif
224#if __HAVE_FLOAT128
225 _Float128 side_float_binary128;
226#endif
de4ae6e8 227} SIDE_PACKED;
a4969f31
MD		 228
229struct side_attr_value {
230 uint32_t type; /* enum side_attr_type */
231 union {
5f82db91
MD		 232 uint8_t bool_value;
233 uint64_t string_value; /* const char * */
d37fe349
MD		 234 union side_integer_value integer_value;
235 union side_float_value float_value;
de4ae6e8 236 } SIDE_PACKED u;
bc3c89b3
MD		 237};
238
65010f43
MD		 239/* User attributes. */
240struct side_attr {
241 const char *key;
bc3c89b3 242 const struct side_attr_value value;
de4ae6e8 243} SIDE_PACKED;
65010f43 244
169a8a57
MD		 245/* Type descriptions */
246struct side_type_null {
247 const struct side_attr *attr;
248 uint32_t nr_attr;
249} SIDE_PACKED;
250
251struct side_type_bool {
252 const struct side_attr *attr;
253 uint32_t nr_attr;
254} SIDE_PACKED;
255
256struct side_type_byte {
257 const struct side_attr *attr;
258 uint32_t nr_attr;
259} SIDE_PACKED;
260
261struct side_type_dynamic {
262 const struct side_attr *attr;
263 uint32_t nr_attr;
264} SIDE_PACKED;
265
266struct side_type_string {
267 const struct side_attr *attr;
268 uint32_t nr_attr;
269} SIDE_PACKED;
270
87405d12
MD		 271struct side_type_integer {
272 const struct side_attr *attr;
273 uint32_t nr_attr;
274 uint16_t integer_size_bits; /* bits */
275 uint16_t len_bits; /* bits */
276 uint8_t signedness; /* true/false */
277 uint8_t byte_order; /* enum side_type_byte_order */
de4ae6e8 278} SIDE_PACKED;
87405d12
MD		 279
280struct side_type_float {
281 const struct side_attr *attr;
282 uint32_t nr_attr;
283 uint32_t byte_order; /* enum side_type_byte_order */
284 uint16_t float_size_bits; /* bits */
de4ae6e8 285} SIDE_PACKED;
87405d12 286
79f677ba
MD		 287struct side_enum_mapping {
288 int64_t range_begin;
289 int64_t range_end;
290 const char *label;
de4ae6e8 291} SIDE_PACKED;
79f677ba
MD		 292
293struct side_enum_mappings {
294 const struct side_enum_mapping *mappings;
d4328528 295 const struct side_attr *attr;
79f677ba 296 uint32_t nr_mappings;
d4328528 297 uint32_t nr_attr;
de4ae6e8 298} SIDE_PACKED;
79f677ba 299
66cff328 300struct side_enum_bitmap_mapping {
9ff49ee4
MD		 301 uint64_t range_begin;
302 uint64_t range_end;
66cff328 303 const char *label;
de4ae6e8 304} SIDE_PACKED;
66cff328
MD		 305
306struct side_enum_bitmap_mappings {
307 const struct side_enum_bitmap_mapping *mappings;
d4328528 308 const struct side_attr *attr;
66cff328 309 uint32_t nr_mappings;
d4328528 310 uint32_t nr_attr;
de4ae6e8 311} SIDE_PACKED;
66cff328 312
c7a14585
MD		 313struct side_type_struct {
314 uint32_t nr_fields;
315 uint32_t nr_attr;
316 const struct side_event_field *fields;
317 const struct side_attr *attr;
de4ae6e8 318} SIDE_PACKED;
c7a14585 319
7a1cb105 320struct side_type_sg_description {
87405d12
MD		 321 uint64_t offset; /* bytes */
322 uint32_t type; /* enum side_type_sg */
7a1cb105 323 union {
9b641221 324 struct side_type_null side_null;
7a1cb105 325 struct {
87405d12
MD		 326 struct side_type_integer type;
327 uint16_t offset_bits; /* bits */
de4ae6e8
MD		 328 } SIDE_PACKED side_integer;
329 } SIDE_PACKED u;
330} SIDE_PACKED;
7a1cb105
MD		 331
332struct side_struct_field_sg {
333 const char *field_name;
334 struct side_type_sg_description side_type;
de4ae6e8 335} SIDE_PACKED;
7a1cb105
MD		 336
337/* Structure fields scatter-gather. */
338struct side_type_struct_sg {
339 uint32_t nr_fields;
340 uint32_t nr_attr;
341 const struct side_struct_field_sg *fields_sg;
342 const struct side_attr *attr;
de4ae6e8 343} SIDE_PACKED;
7a1cb105 344
f611d0c3 345struct side_type_description {
2f5827d5 346 uint32_t type; /* enum side_type */
f611d0c3 347 union {
e24949fa 348 /* Basic types */
9b641221 349 struct side_type_null side_null;
5f82db91
MD		 350 struct side_type_bool side_bool;
351 struct side_type_byte side_byte;
352 struct side_type_dynamic side_dynamic;
353 struct side_type_string side_string;
56c21987 354 struct side_type_integer side_integer;
d44b44d1 355 struct side_type_float side_float;
56c21987 356
e24949fa 357 /* Compound types */
d4328528 358 struct {
f611d0c3 359 const struct side_type_description *elem_type;
d4328528
MD		 360 const struct side_attr *attr;
361 uint32_t length;
362 uint32_t nr_attr;
de4ae6e8 363 } SIDE_PACKED side_array;
f611d0c3
MD		 364 struct {
365 const struct side_type_description *elem_type;
d4328528
MD		 366 const struct side_attr *attr;
367 uint32_t nr_attr;
de4ae6e8 368 } SIDE_PACKED side_vla;
f611d0c3
MD		 369 struct {
370 const struct side_type_description *elem_type;
352a4b77 371 side_visitor visitor;
d4328528
MD		 372 const struct side_attr *attr;
373 uint32_t nr_attr;
de4ae6e8 374 } SIDE_PACKED side_vla_visitor;
d4328528 375 const struct side_type_struct *side_struct;
7a1cb105 376 const struct side_type_struct_sg *side_struct_sg;
af6aa6e1
MD		 377
378 /* Enumeration types */
d8be25de 379 struct {
d8be25de 380 const struct side_enum_mappings *mappings;
f89c4ad1 381 const struct side_type_description *elem_type;
de4ae6e8 382 } SIDE_PACKED side_enum;
af6aa6e1 383 struct {
af6aa6e1 384 const struct side_enum_bitmap_mappings *mappings;
f89c4ad1 385 const struct side_type_description *elem_type;
de4ae6e8
MD		 386 } SIDE_PACKED side_enum_bitmap;
387 } SIDE_PACKED u;
388} SIDE_PACKED;
f611d0c3
MD		 389
390struct side_event_field {
391 const char *field_name;
392 struct side_type_description side_type;
de4ae6e8 393} SIDE_PACKED;
f611d0c3 394
8a25ce77
MD		 395enum side_event_flags {
396 SIDE_EVENT_FLAG_VARIADIC = (1 << 0),
397};
398
d89fabc8
MD		 399struct side_callback {
400 union {
401 void (*call)(const struct side_event_description *desc,
402 const struct side_arg_vec_description *sav_desc,
403 void *priv);
404 void (*call_variadic)(const struct side_event_description *desc,
405 const struct side_arg_vec_description *sav_desc,
406 const struct side_arg_dynamic_event_struct *var_struct,
407 void *priv);
de4ae6e8 408 } SIDE_PACKED u;
d89fabc8 409 void *priv;
de4ae6e8 410} SIDE_PACKED;
d89fabc8 411
f611d0c3 412struct side_event_description {
83a72806 413 uintptr_t *enabled;
f611d0c3
MD		 414 const char *provider_name;
415 const char *event_name;
416 const struct side_event_field *fields;
65010f43 417 const struct side_attr *attr;
054b7b5c 418 const struct side_callback *callbacks;
83a72806
MD		 419 uint64_t flags;
420 uint32_t version;
421 uint32_t loglevel; /* enum side_loglevel */
422 uint32_t nr_fields;
423 uint32_t nr_attr;
424 uint32_t nr_callbacks;
de4ae6e8 425} SIDE_PACKED;
f611d0c3 426
bdc39c09 427struct side_arg_dynamic_vec {
2f5827d5 428 uint32_t dynamic_type; /* enum side_dynamic_type */
bdc39c09 429 union {
9b641221 430 struct side_type_null side_null;
5f82db91 431
e24949fa 432 /* Basic types */
8d20e708 433 struct {
5f82db91
MD		 434 struct side_type_bool type;
435 uint8_t value;
de4ae6e8 436 } SIDE_PACKED side_bool;
5f82db91
MD		 437
438 struct {
439 struct side_type_byte type;
440 uint8_t value;
de4ae6e8 441 } SIDE_PACKED side_byte;
5f82db91
MD		 442
443 struct {
444 struct side_type_string type;
445 uint64_t value; /* const char * */
de4ae6e8 446 } SIDE_PACKED side_string;
bdc39c09 447
d2be7696
MD		 448 /* Integer type */
449 struct {
450 struct side_type_integer type;
451 union side_integer_value value;
de4ae6e8 452 } SIDE_PACKED side_integer;
d2be7696 453
aac52685
MD		 454 struct {
455 struct side_type_float type;
456 union side_float_value value;
de4ae6e8 457 } SIDE_PACKED side_float;
aac52685 458
e24949fa 459 /* Compound types */
c208889e 460 const struct side_arg_dynamic_event_struct *side_dynamic_struct;
bdc39c09 461 struct {
8ceca0cd 462 void *app_ctx;
c208889e 463 side_dynamic_struct_visitor visitor;
8d20e708
MD		 464 const struct side_attr *attr;
465 uint32_t nr_attr;
de4ae6e8 466 } SIDE_PACKED side_dynamic_struct_visitor;
a2e2357e 467 const struct side_arg_dynamic_vec_vla *side_dynamic_vla;
bdc39c09 468 struct {
8ceca0cd 469 void *app_ctx;
bdc39c09 470 side_dynamic_vla_visitor visitor;
8d20e708
MD		 471 const struct side_attr *attr;
472 uint32_t nr_attr;
de4ae6e8
MD		 473 } SIDE_PACKED side_dynamic_vla_visitor;
474 } SIDE_PACKED u;
475} SIDE_PACKED;
bdc39c09 476
8d20e708
MD		 477struct side_arg_dynamic_vec_vla {
478 const struct side_arg_dynamic_vec *sav;
479 const struct side_attr *attr;
480 uint32_t len;
481 uint32_t nr_attr;
de4ae6e8 482} SIDE_PACKED;
8d20e708 483
465e5e7e
MD		 484struct side_arg_dynamic_event_field {
485 const char *field_name;
486 const struct side_arg_dynamic_vec elem;
de4ae6e8 487} SIDE_PACKED;
465e5e7e 488
c208889e 489struct side_arg_dynamic_event_struct {
465e5e7e 490 const struct side_arg_dynamic_event_field *fields;
8d20e708 491 const struct side_attr *attr;
465e5e7e 492 uint32_t len;
8d20e708 493 uint32_t nr_attr;
de4ae6e8 494} SIDE_PACKED;
465e5e7e 495
f611d0c3 496struct side_arg_vec {
1e8256c9 497 enum side_type type;
f611d0c3 498 union {
56c21987 499 /* Basic types */
5f82db91
MD		 500 uint8_t bool_value;
501 uint8_t byte_value;
502 uint64_t string_value; /* const char * */
503 union side_integer_value integer_value;
d37fe349 504 union side_float_value float_value;
e24949fa
MD		 505
506 /* Compound types */
f611d0c3
MD		 507 const struct side_arg_vec_description *side_struct;
508 const struct side_arg_vec_description *side_array;
509 const struct side_arg_vec_description *side_vla;
352a4b77 510 void *side_vla_app_visitor_ctx;
ba845af5 511 void *side_array_fixint;
1533629f
MD		 512 struct {
513 void *p;
514 uint32_t length;
de4ae6e8 515 } SIDE_PACKED side_vla_fixint;
7a1cb105 516 void *side_struct_sg_ptr;
bdc39c09 517
e24949fa 518 /* Dynamic type */
5f82db91 519 struct side_arg_dynamic_vec dynamic_value;
de4ae6e8
MD		 520 } SIDE_PACKED u;
521} SIDE_PACKED;
f611d0c3
MD		 522
523struct side_arg_vec_description {
524 const struct side_arg_vec *sav;
525 uint32_t len;
de4ae6e8 526} SIDE_PACKED;
f611d0c3 527
352a4b77
MD		 528/* The visitor pattern is a double-dispatch visitor. */
529struct side_tracer_visitor_ctx {
f93e01ac
MD		 530 enum side_visitor_status (*write_elem)(
531 const struct side_tracer_visitor_ctx *tracer_ctx,
532 const struct side_arg_vec *elem);
352a4b77 533 void *priv; /* Private tracer context. */
de4ae6e8 534} SIDE_PACKED;
352a4b77 535
c208889e 536struct side_tracer_dynamic_struct_visitor_ctx {
f93e01ac
MD		 537 enum side_visitor_status (*write_field)(
538 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
2b359235 539 const struct side_arg_dynamic_event_field *dynamic_field);
bdc39c09 540 void *priv; /* Private tracer context. */
de4ae6e8 541} SIDE_PACKED;
bdc39c09
MD		 542
543struct side_tracer_dynamic_vla_visitor_ctx {
f93e01ac
MD		 544 enum side_visitor_status (*write_elem)(
545 const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
546 const struct side_arg_dynamic_vec *elem);
bdc39c09 547 void *priv; /* Private tracer context. */
de4ae6e8 548} SIDE_PACKED;
bdc39c09 549
e24949fa
MD		 550/* Event and type attributes */
551
dd6e76cb
MD		 552#if SIDE_BITS_PER_LONG == 64
553# define SIDE_TYPE_POINTER_HOST SIDE_TYPE_POINTER64
554# define SIDE_TYPE_ARRAY_POINTER_HOST SIDE_TYPE_ARRAY_POINTER64
555# define SIDE_TYPE_VLA_POINTER_HOST SIDE_TYPE_VLA_POINTER64
556# define SIDE_DYNAMIC_TYPE_POINTER_HOST SIDE_DYNAMIC_TYPE_POINTER64
557# define SIDE_ATTR_TYPE_POINTER_HOST SIDE_ATTR_TYPE_POINTER64
35d25fc5 558# define SIDE_PTR_HOST .side_u64
dd6e76cb
MD		 559#else
560# define SIDE_TYPE_POINTER_HOST SIDE_TYPE_POINTER32
561# define SIDE_TYPE_ARRAY_POINTER_HOST SIDE_TYPE_ARRAY_POINTER32
562# define SIDE_TYPE_VLA_POINTER_HOST SIDE_TYPE_VLA_POINTER32
563# define SIDE_DYNAMIC_TYPE_POINTER_HOST SIDE_DYNAMIC_TYPE_POINTER32
564# define SIDE_ATTR_TYPE_POINTER_HOST SIDE_ATTR_TYPE_POINTER32
35d25fc5 565# define SIDE_PTR_HOST .side_u32
dd6e76cb
MD		 566#endif
567
65010f43
MD		 568#define side_attr(_key, _value) \
569 { \
570 .key = _key, \
bc3c89b3 571 .value = SIDE_PARAM(_value), \
65010f43
MD		 572 }
573
574#define side_attr_list(...) \
575 SIDE_COMPOUND_LITERAL(const struct side_attr, __VA_ARGS__)
576
e2c978ee 577#define side_attr_null(_val) { .type = SIDE_ATTR_TYPE_NULL }
5f82db91 578#define side_attr_bool(_val) { .type = SIDE_ATTR_TYPE_BOOL, .u = { .bool_value = !!(_val) } }
35d25fc5
MD		 579#define side_attr_u8(_val) { .type = SIDE_ATTR_TYPE_U8, .u = { .integer_value = { .side_u8 = (_val) } } }
580#define side_attr_u16(_val) { .type = SIDE_ATTR_TYPE_U16, .u = { .integer_value = { .side_u16 = (_val) } } }
581#define side_attr_u32(_val) { .type = SIDE_ATTR_TYPE_U32, .u = { .integer_value = { .side_u32 = (_val) } } }
582#define side_attr_u64(_val) { .type = SIDE_ATTR_TYPE_U64, .u = { .integer_value = { .side_u64 = (_val) } } }
583#define side_attr_s8(_val) { .type = SIDE_ATTR_TYPE_S8, .u = { .integer_value = { .side_s8 = (_val) } } }
584#define side_attr_s16(_val) { .type = SIDE_ATTR_TYPE_S16, .u = { .integer_value = { .side_s16 = (_val) } } }
585#define side_attr_s32(_val) { .type = SIDE_ATTR_TYPE_S32, .u = { .integer_value = { .side_s32 = (_val) } } }
586#define side_attr_s64(_val) { .type = SIDE_ATTR_TYPE_S64, .u = { .integer_value = { .side_s64 = (_val) } } }
587#define side_attr_pointer(_val) { .type = SIDE_ATTR_TYPE_POINTER_HOST, .u = { .integer_value = { SIDE_PTR_HOST = (uintptr_t) (_val) } } }
588#define side_attr_float_binary16(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY16, .u = { .float_value = { .side_float_binary16 = (_val) } } }
589#define side_attr_float_binary32(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY32, .u = { .float_value = { .side_float_binary32 = (_val) } } }
590#define side_attr_float_binary64(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY64, .u = { .float_value = { .side_float_binary64 = (_val) } } }
591#define side_attr_float_binary128(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY128, .u = { .float_value = { .side_float_binary128 = (_val) } } }
5f82db91 592#define side_attr_string(_val) { .type = SIDE_ATTR_TYPE_STRING, .u = { .string_value = (uintptr_t) (_val) } }
e24949fa
MD		 593
594/* Static field definition */
595
9b641221
MD		 596#define side_type_null(_attr) \
597 { \
598 .type = SIDE_TYPE_NULL, \
599 .u = { \
600 .side_null = { \
601 .attr = _attr, \
602 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
603 }, \
604 }, \
605 }
606
5f82db91 607#define side_type_bool(_attr) \
f37a556f 608 { \
5f82db91
MD		 609 .type = SIDE_TYPE_BOOL, \
610 .u = { \
611 .side_bool = { \
612 .attr = _attr, \
613 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
614 }, \
615 }, \
616 }
617
618#define side_type_byte(_attr) \
619 { \
620 .type = SIDE_TYPE_BYTE, \
d4328528 621 .u = { \
5f82db91
MD		 622 .side_byte = { \
623 .attr = _attr, \
624 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
625 }, \
626 }, \
627 }
628
629#define side_type_string(_attr) \
630 { \
631 .type = SIDE_TYPE_STRING, \
632 .u = { \
633 .side_string = { \
634 .attr = _attr, \
635 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
636 }, \
637 }, \
638 }
639
640#define side_type_dynamic(_attr) \
641 { \
642 .type = SIDE_TYPE_DYNAMIC, \
643 .u = { \
644 .side_dynamic = { \
d4328528
MD		 645 .attr = _attr, \
646 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
647 }, \
648 }, \
f37a556f 649 }
f93e01ac 650
56c21987
MD		 651#define _side_type_integer(_type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
652 { \
653 .type = _type, \
654 .u = { \
655 .side_integer = { \
656 .attr = _attr, \
657 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
56c21987
MD		 658 .integer_size_bits = _integer_size_bits, \
659 .len_bits = _len_bits, \
984bcab7
MD		 660 .signedness = _signedness, \
661 .byte_order = _byte_order, \
56c21987
MD		 662 }, \
663 }, \
664 }
665
d44b44d1
MD		 666#define _side_type_float(_type, _byte_order, _float_size_bits, _attr) \
667 { \
668 .type = _type, \
669 .u = { \
670 .side_float = { \
671 .attr = _attr, \
672 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
673 .byte_order = _byte_order, \
674 .float_size_bits = _float_size_bits, \
675 }, \
676 }, \
677 }
678
cb6f04c2 679#define _side_field(_name, _type) \
f93e01ac
MD		 680 { \
681 .field_name = _name, \
cb6f04c2 682 .side_type = _type, \
f93e01ac 683 }
f611d0c3 684
8bdd5c12 685/* Host endian */
56c21987
MD		 686#define side_type_u8(_attr) _side_type_integer(SIDE_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
687#define side_type_u16(_attr) _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
688#define side_type_u32(_attr) _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
689#define side_type_u64(_attr) _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
690#define side_type_s8(_attr) _side_type_integer(SIDE_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
691#define side_type_s16(_attr) _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
692#define side_type_s32(_attr) _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
693#define side_type_s64(_attr) _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
3fa64a4c
MD		 694#define side_type_pointer(_attr) _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_BITS_PER_LONG, \
695 SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
d44b44d1
MD		 696#define side_type_float_binary16(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 16, SIDE_PARAM(_attr))
697#define side_type_float_binary32(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 32, SIDE_PARAM(_attr))
698#define side_type_float_binary64(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 64, SIDE_PARAM(_attr))
699#define side_type_float_binary128(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 128, SIDE_PARAM(_attr))
8bdd5c12 700
9b641221 701#define side_field_null(_name, _attr) _side_field(_name, side_type_null(SIDE_PARAM(_attr)))
cb6f04c2
MD		 702#define side_field_bool(_name, _attr) _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
703#define side_field_u8(_name, _attr) _side_field(_name, side_type_u8(SIDE_PARAM(_attr)))
704#define side_field_u16(_name, _attr) _side_field(_name, side_type_u16(SIDE_PARAM(_attr)))
705#define side_field_u32(_name, _attr) _side_field(_name, side_type_u32(SIDE_PARAM(_attr)))
706#define side_field_u64(_name, _attr) _side_field(_name, side_type_u64(SIDE_PARAM(_attr)))
707#define side_field_s8(_name, _attr) _side_field(_name, side_type_s8(SIDE_PARAM(_attr)))
708#define side_field_s16(_name, _attr) _side_field(_name, side_type_s16(SIDE_PARAM(_attr)))
709#define side_field_s32(_name, _attr) _side_field(_name, side_type_s32(SIDE_PARAM(_attr)))
710#define side_field_s64(_name, _attr) _side_field(_name, side_type_s64(SIDE_PARAM(_attr)))
f7653b43 711#define side_field_byte(_name, _attr) _side_field(_name, side_type_byte(SIDE_PARAM(_attr)))
f5e650d7 712#define side_field_pointer(_name, _attr) _side_field(_name, side_type_pointer(SIDE_PARAM(_attr)))
cb6f04c2
MD		 713#define side_field_float_binary16(_name, _attr) _side_field(_name, side_type_float_binary16(SIDE_PARAM(_attr)))
714#define side_field_float_binary32(_name, _attr) _side_field(_name, side_type_float_binary32(SIDE_PARAM(_attr)))
715#define side_field_float_binary64(_name, _attr) _side_field(_name, side_type_float_binary64(SIDE_PARAM(_attr)))
716#define side_field_float_binary128(_name, _attr) _side_field(_name, side_type_float_binary128(SIDE_PARAM(_attr)))
717#define side_field_string(_name, _attr) _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
718#define side_field_dynamic(_name, _attr) _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
485b800a 719
8bdd5c12 720/* Little endian */
56c21987
MD		 721#define side_type_u16_le(_attr) _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
722#define side_type_u32_le(_attr) _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
723#define side_type_u64_le(_attr) _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
724#define side_type_s16_le(_attr) _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
725#define side_type_s32_le(_attr) _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
726#define side_type_s64_le(_attr) _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
3fa64a4c
MD		 727#define side_type_pointer_le(_attr) _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_LE, SIDE_BITS_PER_LONG, \
728 SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
d44b44d1
MD		 729#define side_type_float_binary16_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_LE, 16, SIDE_PARAM(_attr))
730#define side_type_float_binary32_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_LE, 32, SIDE_PARAM(_attr))
731#define side_type_float_binary64_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_LE, 64, SIDE_PARAM(_attr))
732#define side_type_float_binary128_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_LE, 128, SIDE_PARAM(_attr))
8bdd5c12
MD		 733
734#define side_field_u16_le(_name, _attr) _side_field(_name, side_type_u16_le(SIDE_PARAM(_attr)))
735#define side_field_u32_le(_name, _attr) _side_field(_name, side_type_u32_le(SIDE_PARAM(_attr)))
736#define side_field_u64_le(_name, _attr) _side_field(_name, side_type_u64_le(SIDE_PARAM(_attr)))
737#define side_field_s16_le(_name, _attr) _side_field(_name, side_type_s16_le(SIDE_PARAM(_attr)))
738#define side_field_s32_le(_name, _attr) _side_field(_name, side_type_s32_le(SIDE_PARAM(_attr)))
739#define side_field_s64_le(_name, _attr) _side_field(_name, side_type_s64_le(SIDE_PARAM(_attr)))
f5e650d7 740#define side_field_pointer_le(_name, _attr) _side_field(_name, side_type_pointer_le(SIDE_PARAM(_attr)))
8bdd5c12
MD		 741#define side_field_float_binary16_le(_name, _attr) _side_field(_name, side_type_float_binary16_le(SIDE_PARAM(_attr)))
742#define side_field_float_binary32_le(_name, _attr) _side_field(_name, side_type_float_binary32_le(SIDE_PARAM(_attr)))
743#define side_field_float_binary64_le(_name, _attr) _side_field(_name, side_type_float_binary64_le(SIDE_PARAM(_attr)))
744#define side_field_float_binary128_le(_name, _attr) _side_field(_name, side_type_float_binary128_le(SIDE_PARAM(_attr)))
745
746/* Big endian */
56c21987
MD		 747#define side_type_u16_be(_attr) _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
748#define side_type_u32_be(_attr) _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
749#define side_type_u64_be(_attr) _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
750#define side_type_s16_be(_attr) _side_type_integer(SIDE_TYPE_S16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
751#define side_type_s32_be(_attr) _side_type_integer(SIDE_TYPE_S32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
752#define side_type_s64_be(_attr) _side_type_integer(SIDE_TYPE_S64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
3fa64a4c
MD		 753#define side_type_pointer_be(_attr) _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_BE, SIDE_BITS_PER_LONG, \
754 SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
d44b44d1
MD		 755#define side_type_float_binary16_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_BE, 16, SIDE_PARAM(_attr))
756#define side_type_float_binary32_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_BE, 32, SIDE_PARAM(_attr))
757#define side_type_float_binary64_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_BE, 64, SIDE_PARAM(_attr))
758#define side_type_float_binary128_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_BE, 128, SIDE_PARAM(_attr))
8bdd5c12
MD		 759
760#define side_field_u16_be(_name, _attr) _side_field(_name, side_type_u16_be(SIDE_PARAM(_attr)))
761#define side_field_u32_be(_name, _attr) _side_field(_name, side_type_u32_be(SIDE_PARAM(_attr)))
762#define side_field_u64_be(_name, _attr) _side_field(_name, side_type_u64_be(SIDE_PARAM(_attr)))
763#define side_field_s16_be(_name, _attr) _side_field(_name, side_type_s16_be(SIDE_PARAM(_attr)))
764#define side_field_s32_be(_name, _attr) _side_field(_name, side_type_s32_be(SIDE_PARAM(_attr)))
765#define side_field_s64_be(_name, _attr) _side_field(_name, side_type_s64_be(SIDE_PARAM(_attr)))
f5e650d7 766#define side_field_pointer_be(_name, _attr) _side_field(_name, side_type_pointer_be(SIDE_PARAM(_attr)))
8bdd5c12
MD		 767#define side_field_float_binary16_be(_name, _attr) _side_field(_name, side_type_float_binary16_be(SIDE_PARAM(_attr)))
768#define side_field_float_binary32_be(_name, _attr) _side_field(_name, side_type_float_binary32_be(SIDE_PARAM(_attr)))
769#define side_field_float_binary64_be(_name, _attr) _side_field(_name, side_type_float_binary64_be(SIDE_PARAM(_attr)))
770#define side_field_float_binary128_be(_name, _attr) _side_field(_name, side_type_float_binary128_be(SIDE_PARAM(_attr)))
771
f89c4ad1 772#define side_type_enum(_mappings, _elem_type) \
79f677ba 773 { \
d8be25de 774 .type = SIDE_TYPE_ENUM, \
79f677ba 775 .u = { \
d8be25de 776 .side_enum = { \
d8be25de 777 .mappings = _mappings, \
f89c4ad1 778 .elem_type = _elem_type, \
d8be25de 779 }, \
79f677ba
MD		 780 }, \
781 }
f89c4ad1
MD		 782#define side_field_enum(_name, _mappings, _elem_type) \
783 _side_field(_name, side_type_enum(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
d4328528 784
f89c4ad1 785#define side_type_enum_bitmap(_mappings, _elem_type) \
af6aa6e1 786 { \
bab5d6e4 787 .type = SIDE_TYPE_ENUM_BITMAP, \
af6aa6e1 788 .u = { \
bab5d6e4 789 .side_enum_bitmap = { \
af6aa6e1 790 .mappings = _mappings, \
f89c4ad1 791 .elem_type = _elem_type, \
af6aa6e1
MD		 792 }, \
793 }, \
794 }
f89c4ad1
MD		 795#define side_field_enum_bitmap(_name, _mappings, _elem_type) \
796 _side_field(_name, side_type_enum_bitmap(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
66cff328 797
c7a14585 798#define side_type_struct(_struct) \
f611d0c3
MD		 799 { \
800 .type = SIDE_TYPE_STRUCT, \
801 .u = { \
c7a14585 802 .side_struct = _struct, \
f611d0c3
MD		 803 }, \
804 }
c7a14585
MD		 805#define side_field_struct(_name, _struct) \
806 _side_field(_name, side_type_struct(SIDE_PARAM(_struct)))
807
808#define _side_type_struct_define(_fields, _attr) \
809 { \
810 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
811 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
812 .fields = _fields, \
813 .attr = _attr, \
814 }
815
816#define side_define_struct(_identifier, _fields, _attr) \
817 const struct side_type_struct _identifier = _side_type_struct_define(SIDE_PARAM(_fields), SIDE_PARAM(_attr))
818
819#define side_struct_literal(_fields, _attr) \
820 SIDE_COMPOUND_LITERAL(const struct side_type_struct, \
821 _side_type_struct_define(SIDE_PARAM(_fields), SIDE_PARAM(_attr)))
f611d0c3 822
7a1cb105
MD		 823/* Scatter-gather struct */
824
9b641221
MD		 825#define _side_field_sg(_name, _type) \
826 { \
827 .field_name = _name, \
828 .side_type = _type, \
829 }
830
831#define side_type_sg_null(_attr) \
832 { \
833 .offset = 0, \
834 .type = SIDE_TYPE_SG_NULL, \
835 .u = { \
836 .side_null = { \
837 .attr = _attr, \
838 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
839 }, \
840 }, \
841 }
842
843#define side_field_sg_null(_name, _attr) \
844 _side_field_sg(_name, side_type_sg_null(SIDE_PARAM(_attr)))
845
87405d12 846#define _side_type_sg_integer(_type, _signedness, _byte_order, _offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
7a1cb105 847 { \
87405d12 848 .offset = _offset, \
7a1cb105
MD		 849 .type = _type, \
850 .u = { \
87405d12
MD		 851 .side_integer = { \
852 .type = { \
853 .attr = _attr, \
854 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
855 .integer_size_bits = _integer_size_bits, \
856 .len_bits = _len_bits, \
857 .signedness = _signedness, \
858 .byte_order = _byte_order, \
859 }, \
7a1cb105 860 .offset_bits = _offset_bits, \
7a1cb105
MD		 861 }, \
862 }, \
863 }
864
7a1cb105 865#define side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
87405d12 866 _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false, SIDE_TYPE_BYTE_ORDER_HOST, \
7a1cb105
MD		 867 _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
868#define side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
87405d12 869 _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_HOST, \
7a1cb105
MD		 870 _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
871
872#define side_field_sg_unsigned_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
873 _side_field_sg(_name, side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
874#define side_field_sg_signed_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
875 _side_field_sg(_name, side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
876
877#define side_type_struct_sg(_struct_sg) \
878 { \
879 .type = SIDE_TYPE_STRUCT_SG, \
880 .u = { \
881 .side_struct_sg = _struct_sg, \
882 }, \
883 }
884#define side_field_struct_sg(_name, _struct_sg) \
885 _side_field(_name, side_type_struct_sg(SIDE_PARAM(_struct_sg)))
886
887#define _side_type_struct_sg_define(_fields_sg, _attr) \
888 { \
889 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields_sg)), \
890 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
891 .fields_sg = _fields_sg, \
892 .attr = _attr, \
893 }
894
895#define side_define_struct_sg(_identifier, _fields_sg, _attr) \
896 const struct side_type_struct_sg _identifier = _side_type_struct_sg_define(SIDE_PARAM(_fields_sg), SIDE_PARAM(_attr))
897
898#define side_struct_sg_literal(_fields_sg, _attr) \
899 SIDE_COMPOUND_LITERAL(const struct side_type_struct_sg, \
900 _side_type_struct_sg_define(SIDE_PARAM(_fields_sg), SIDE_PARAM(_attr)))
901
32ba58fc 902#define side_type_array(_elem_type, _length, _attr) \
f611d0c3
MD		 903 { \
904 .type = SIDE_TYPE_ARRAY, \
905 .u = { \
906 .side_array = { \
f611d0c3 907 .elem_type = _elem_type, \
d4328528
MD		 908 .attr = _attr, \
909 .length = _length, \
910 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
f611d0c3
MD		 911 }, \
912 }, \
913 }
f37a556f 914#define side_field_array(_name, _elem_type, _length, _attr) \
be14d73f 915 _side_field(_name, side_type_array(SIDE_PARAM(_elem_type), _length, SIDE_PARAM(_attr)))
f611d0c3 916
32ba58fc 917#define side_type_vla(_elem_type, _attr) \
f611d0c3
MD		 918 { \
919 .type = SIDE_TYPE_VLA, \
920 .u = { \
921 .side_vla = { \
922 .elem_type = _elem_type, \
d4328528
MD		 923 .attr = _attr, \
924 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
f611d0c3
MD		 925 }, \
926 }, \
927 }
f37a556f 928#define side_field_vla(_name, _elem_type, _attr) \
be14d73f 929 _side_field(_name, side_type_vla(SIDE_PARAM(_elem_type), SIDE_PARAM(_attr)))
f611d0c3 930
32ba58fc 931#define side_type_vla_visitor(_elem_type, _visitor, _attr) \
f611d0c3
MD		 932 { \
933 .type = SIDE_TYPE_VLA_VISITOR, \
934 .u = { \
935 .side_vla_visitor = { \
cdd6e858 936 .elem_type = SIDE_PARAM(_elem_type), \
352a4b77 937 .visitor = _visitor, \
d4328528
MD		 938 .attr = _attr, \
939 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
f611d0c3
MD		 940 }, \
941 }, \
942 }
f37a556f 943#define side_field_vla_visitor(_name, _elem_type, _visitor, _attr) \
be14d73f 944 _side_field(_name, side_type_vla_visitor(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)))
f611d0c3 945
71002b5e 946#define side_elem(...) \
cdd6e858
MD		 947 SIDE_COMPOUND_LITERAL(const struct side_type_description, __VA_ARGS__)
948
f611d0c3
MD		 949#define side_field_list(...) \
950 SIDE_COMPOUND_LITERAL(const struct side_event_field, __VA_ARGS__)
951
7a1cb105
MD		 952#define side_field_sg_list(...) \
953 SIDE_COMPOUND_LITERAL(const struct side_struct_field_sg, __VA_ARGS__)
954
e24949fa
MD		 955/* Static field arguments */
956
9b641221 957#define side_arg_null(_val) { .type = SIDE_TYPE_NULL }
5f82db91
MD		 958#define side_arg_bool(_val) { .type = SIDE_TYPE_BOOL, .u = { .bool_value = !!(_val) } }
959#define side_arg_byte(_val) { .type = SIDE_TYPE_BYTE, .u = { .byte_value = (_val) } }
960#define side_arg_string(_val) { .type = SIDE_TYPE_STRING, .u = { .string_value = (uintptr_t) (_val) } }
961#define side_arg_dynamic(_dynamic_arg_type) { .type = SIDE_TYPE_DYNAMIC, .u = { .dynamic_value = _dynamic_arg_type } }
962
35d25fc5
MD		 963#define side_arg_u8(_val) { .type = SIDE_TYPE_U8, .u = { .integer_value = { .side_u8 = (_val) } } }
964#define side_arg_u16(_val) { .type = SIDE_TYPE_U16, .u = { .integer_value = { .side_u16 = (_val) } } }
965#define side_arg_u32(_val) { .type = SIDE_TYPE_U32, .u = { .integer_value = { .side_u32 = (_val) } } }
966#define side_arg_u64(_val) { .type = SIDE_TYPE_U64, .u = { .integer_value = { .side_u64 = (_val) } } }
967#define side_arg_s8(_val) { .type = SIDE_TYPE_S8, .u = { .integer_value = { .side_s8 = (_val) } } }
968#define side_arg_s16(_val) { .type = SIDE_TYPE_S16, .u = { .integer_value = { .side_s16 = (_val) } } }
969#define side_arg_s32(_val) { .type = SIDE_TYPE_S32, .u = { .integer_value = { .side_s32 = (_val) } } }
970#define side_arg_s64(_val) { .type = SIDE_TYPE_S64, .u = { .integer_value = { .side_s64 = (_val) } } }
35d25fc5
MD		 971#define side_arg_pointer(_val) { .type = SIDE_TYPE_POINTER_HOST, .u = { .integer_value = { SIDE_PTR_HOST = (uintptr_t) (_val) } } }
972#define side_arg_enum_bitmap8(_val) { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .integer_value = { .side_u8 = (_val) } } }
973#define side_arg_enum_bitmap16(_val) { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .integer_value = { .side_u16 = (_val) } } }
974#define side_arg_enum_bitmap32(_val) { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .integer_value = { .side_u32 = (_val) } } }
975#define side_arg_enum_bitmap64(_val) { .type = SIDE_TYPE_ENUM_BITMAP64, .u = { .integer_value = { .side_u64 = (_val) } } }
af6aa6e1
MD		 976#define side_arg_enum_bitmap_array(_side_type) { .type = SIDE_TYPE_ENUM_BITMAP_ARRAY, .u = { .side_array = (_side_type) } }
977#define side_arg_enum_bitmap_vla(_side_type) { .type = SIDE_TYPE_ENUM_BITMAP_VLA, .u = { .side_vla = (_side_type) } }
35d25fc5
MD		 978#define side_arg_float_binary16(_val) { .type = SIDE_TYPE_FLOAT_BINARY16, .u = { .float_value = { .side_float_binary16 = (_val) } } }
979#define side_arg_float_binary32(_val) { .type = SIDE_TYPE_FLOAT_BINARY32, .u = { .float_value = { .side_float_binary32 = (_val) } } }
980#define side_arg_float_binary64(_val) { .type = SIDE_TYPE_FLOAT_BINARY64, .u = { .float_value = { .side_float_binary64 = (_val) } } }
981#define side_arg_float_binary128(_val) { .type = SIDE_TYPE_FLOAT_BINARY128, .u = { .float_value = { .side_float_binary128 = (_val) } } }
e24949fa 982
f611d0c3 983#define side_arg_struct(_side_type) { .type = SIDE_TYPE_STRUCT, .u = { .side_struct = (_side_type) } }
7a1cb105 984#define side_arg_struct_sg(_ptr) { .type = SIDE_TYPE_STRUCT_SG, .u = { .side_struct_sg_ptr = (_ptr) } }
f611d0c3
MD		 985#define side_arg_array(_side_type) { .type = SIDE_TYPE_ARRAY, .u = { .side_array = (_side_type) } }
986#define side_arg_vla(_side_type) { .type = SIDE_TYPE_VLA, .u = { .side_vla = (_side_type) } }
352a4b77 987#define side_arg_vla_visitor(_ctx) { .type = SIDE_TYPE_VLA_VISITOR, .u = { .side_vla_app_visitor_ctx = (_ctx) } }
f611d0c3 988
1533629f
MD		 989#define side_arg_array_u8(_ptr) { .type = SIDE_TYPE_ARRAY_U8, .u = { .side_array_fixint = (_ptr) } }
990#define side_arg_array_u16(_ptr) { .type = SIDE_TYPE_ARRAY_U16, .u = { .side_array_fixint = (_ptr) } }
991#define side_arg_array_u32(_ptr) { .type = SIDE_TYPE_ARRAY_U32, .u = { .side_array_fixint = (_ptr) } }
992#define side_arg_array_u64(_ptr) { .type = SIDE_TYPE_ARRAY_U64, .u = { .side_array_fixint = (_ptr) } }
993#define side_arg_array_s8(_ptr) { .type = SIDE_TYPE_ARRAY_S8, .u = { .side_array_fixint = (_ptr) } }
994#define side_arg_array_s16(_ptr) { .type = SIDE_TYPE_ARRAY_S16, .u = { .side_array_fixint = (_ptr) } }
995#define side_arg_array_s32(_ptr) { .type = SIDE_TYPE_ARRAY_S32, .u = { .side_array_fixint = (_ptr) } }
996#define side_arg_array_s64(_ptr) { .type = SIDE_TYPE_ARRAY_S64, .u = { .side_array_fixint = (_ptr) } }
f7653b43 997#define side_arg_array_byte(_ptr) { .type = SIDE_TYPE_ARRAY_BYTE, .u = { .side_array_fixint = (_ptr) } }
dd6e76cb 998#define side_arg_array_pointer(_ptr) { .type = SIDE_TYPE_ARRAY_POINTER_HOST, .u = { .side_array_fixint = (_ptr) } }
1533629f
MD		 999
1000#define side_arg_vla_u8(_ptr, _length) { .type = SIDE_TYPE_VLA_U8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } }
1001#define side_arg_vla_u16(_ptr, _length) { .type = SIDE_TYPE_VLA_U16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
1002#define side_arg_vla_u32(_ptr, _length) { .type = SIDE_TYPE_VLA_U32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
1003#define side_arg_vla_u64(_ptr, _length) { .type = SIDE_TYPE_VLA_U64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
1004#define side_arg_vla_s8(_ptr, _length) { .type = SIDE_TYPE_VLA_S8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
1005#define side_arg_vla_s16(_ptr, _length) { .type = SIDE_TYPE_VLA_S16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
1006#define side_arg_vla_s32(_ptr, _length) { .type = SIDE_TYPE_VLA_S32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
1007#define side_arg_vla_s64(_ptr, _length) { .type = SIDE_TYPE_VLA_S64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
f7653b43 1008#define side_arg_vla_byte(_ptr, _length) { .type = SIDE_TYPE_VLA_BYTE, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
dd6e76cb 1009#define side_arg_vla_pointer(_ptr, _length) { .type = SIDE_TYPE_VLA_POINTER_HOST, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
ba845af5 1010
e24949fa
MD		 1011/* Dynamic field arguments */
1012
808bd9bf
MD		 1013#define side_arg_dynamic_null(_attr) \
1014 { \
1015 .dynamic_type = SIDE_DYNAMIC_TYPE_NULL, \
8d20e708 1016 .u = { \
9b641221 1017 .side_null = { \
8d20e708
MD		 1018 .attr = _attr, \
1019 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1020 }, \
1021 }, \
808bd9bf
MD		 1022 }
1023
1024#define side_arg_dynamic_bool(_val, _attr) \
1025 { \
1026 .dynamic_type = SIDE_DYNAMIC_TYPE_BOOL, \
808bd9bf 1027 .u = { \
5f82db91
MD		 1028 .side_bool = { \
1029 .type = { \
1030 .attr = _attr, \
1031 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8d20e708 1032 }, \
5f82db91 1033 .value = !!(_val), \
8d20e708 1034 }, \
808bd9bf
MD		 1035 }, \
1036 }
1037
8bdd5c12 1038#define side_arg_dynamic_byte(_val, _attr) \
808bd9bf 1039 { \
8bdd5c12 1040 .dynamic_type = SIDE_DYNAMIC_TYPE_BYTE, \
808bd9bf 1041 .u = { \
5f82db91
MD		 1042 .side_byte = { \
1043 .type = { \
1044 .attr = _attr, \
1045 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8d20e708 1046 }, \
5f82db91 1047 .value = (_val), \
8d20e708 1048 }, \
808bd9bf
MD		 1049 }, \
1050 }
8bdd5c12 1051#define side_arg_dynamic_string(_val, _attr) \
808bd9bf 1052 { \
8bdd5c12 1053 .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
808bd9bf 1054 .u = { \
5f82db91
MD		 1055 .side_string = { \
1056 .type = { \
1057 .attr = _attr, \
1058 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8d20e708 1059 }, \
5f82db91 1060 .value = (uintptr_t) (_val), \
8d20e708 1061 }, \
808bd9bf
MD		 1062 }, \
1063 }
1064
d2be7696 1065#define _side_arg_dynamic_integer(_field, _val, _type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
808bd9bf 1066 { \
d2be7696 1067 .dynamic_type = _type, \
808bd9bf 1068 .u = { \
d2be7696
MD		 1069 .side_integer = { \
1070 .type = { \
1071 .attr = _attr, \
1072 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1073 .integer_size_bits = _integer_size_bits, \
1074 .len_bits = _len_bits, \
1075 .signedness = _signedness, \
1076 .byte_order = _byte_order, \
8d20e708 1077 }, \
d2be7696
MD		 1078 .value = { \
1079 _field = (_val), \
8d20e708
MD		 1080 }, \
1081 }, \
808bd9bf
MD		 1082 }, \
1083 }
d2be7696
MD		 1084
1085#define side_arg_dynamic_u8(_val, _attr) \
1086 _side_arg_dynamic_integer(.side_u8, _val, SIDE_DYNAMIC_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
1087#define side_arg_dynamic_s8(_val, _attr) \
1088 _side_arg_dynamic_integer(.side_s8, _val, SIDE_DYNAMIC_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
1089
1090#define _side_arg_dynamic_u16(_val, _byte_order, _attr) \
1091 _side_arg_dynamic_integer(.side_u16, _val, SIDE_DYNAMIC_TYPE_U16, false, _byte_order, 16, 16, SIDE_PARAM(_attr))
1092#define _side_arg_dynamic_u32(_val, _byte_order, _attr) \
1093 _side_arg_dynamic_integer(.side_u32, _val, SIDE_DYNAMIC_TYPE_U32, false, _byte_order, 32, 32, SIDE_PARAM(_attr))
8bdd5c12 1094#define _side_arg_dynamic_u64(_val, _byte_order, _attr) \
d2be7696 1095 _side_arg_dynamic_integer(.side_u64, _val, SIDE_DYNAMIC_TYPE_U64, false, _byte_order, 64, 64, SIDE_PARAM(_attr))
8bdd5c12
MD		 1096
1097#define _side_arg_dynamic_s16(_val, _byte_order, _attr) \
d2be7696 1098 _side_arg_dynamic_integer(.side_s16, _val, SIDE_DYNAMIC_TYPE_S16, true, _byte_order, 16, 16, SIDE_PARAM(_attr))
8bdd5c12 1099#define _side_arg_dynamic_s32(_val, _byte_order, _attr) \
d2be7696 1100 _side_arg_dynamic_integer(.side_s32, _val, SIDE_DYNAMIC_TYPE_S32, true, _byte_order, 32, 32, SIDE_PARAM(_attr))
8bdd5c12 1101#define _side_arg_dynamic_s64(_val, _byte_order, _attr) \
d2be7696
MD		 1102 _side_arg_dynamic_integer(.side_s64, _val, SIDE_DYNAMIC_TYPE_S64, true, _byte_order, 64, 64, SIDE_PARAM(_attr))
1103
f5e650d7 1104#define _side_arg_dynamic_pointer(_val, _byte_order, _attr) \
d2be7696
MD		 1105 _side_arg_dynamic_integer(SIDE_PTR_HOST, (uintptr_t) (_val), SIDE_DYNAMIC_TYPE_POINTER_HOST, false, _byte_order, \
1106 SIDE_BITS_PER_LONG, SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
1107
aac52685 1108#define _side_arg_dynamic_float(_field, _val, _type, _byte_order, _float_size_bits, _attr) \
fb25b355 1109 { \
aac52685 1110 .dynamic_type = _type, \
fb25b355 1111 .u = { \
aac52685
MD		 1112 .side_float = { \
1113 .type = { \
1114 .attr = _attr, \
1115 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1116 .byte_order = _byte_order, \
1117 .float_size_bits = _float_size_bits, \
8d20e708 1118 }, \
aac52685
MD		 1119 .value = { \
1120 _field = (_val), \
8d20e708
MD		 1121 }, \
1122 }, \
fb25b355
MD		 1123 }, \
1124 }
aac52685
MD		 1125
1126#define _side_arg_dynamic_float_binary16(_val, _byte_order, _attr) \
1127 _side_arg_dynamic_float(.side_float_binary16, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, _byte_order, 16, SIDE_PARAM(_attr))
1128#define _side_arg_dynamic_float_binary32(_val, _byte_order, _attr) \
1129 _side_arg_dynamic_float(.side_float_binary32, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY32, _byte_order, 32, SIDE_PARAM(_attr))
8bdd5c12 1130#define _side_arg_dynamic_float_binary64(_val, _byte_order, _attr) \
aac52685 1131 _side_arg_dynamic_float(.side_float_binary64, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY64, _byte_order, 64, SIDE_PARAM(_attr))
8bdd5c12 1132#define _side_arg_dynamic_float_binary128(_val, _byte_order, _attr) \
aac52685 1133 _side_arg_dynamic_float(.side_float_binary128, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY128, _byte_order, 128, SIDE_PARAM(_attr))
808bd9bf 1134
8bdd5c12
MD		 1135/* Host endian */
1136#define side_arg_dynamic_u16(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1137#define side_arg_dynamic_u32(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1138#define side_arg_dynamic_u64(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1139#define side_arg_dynamic_s16(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1140#define side_arg_dynamic_s32(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1141#define side_arg_dynamic_s64(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
f5e650d7 1142#define side_arg_dynamic_pointer(_val, _attr) _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
8bdd5c12
MD		 1143#define side_arg_dynamic_float_binary16(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1144#define side_arg_dynamic_float_binary32(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1145#define side_arg_dynamic_float_binary64(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1146#define side_arg_dynamic_float_binary128(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1147
1148/* Little endian */
1149#define side_arg_dynamic_u16_le(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1150#define side_arg_dynamic_u32_le(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1151#define side_arg_dynamic_u64_le(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1152#define side_arg_dynamic_s16_le(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1153#define side_arg_dynamic_s32_le(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1154#define side_arg_dynamic_s64_le(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
f5e650d7 1155#define side_arg_dynamic_pointer_le(_val, _attr) _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
8bdd5c12
MD		 1156#define side_arg_dynamic_float_binary16_le(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1157#define side_arg_dynamic_float_binary32_le(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1158#define side_arg_dynamic_float_binary64_le(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1159#define side_arg_dynamic_float_binary128_le(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1160
1161/* Big endian */
1162#define side_arg_dynamic_u16_be(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1163#define side_arg_dynamic_u32_be(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1164#define side_arg_dynamic_u64_be(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1165#define side_arg_dynamic_s16_be(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1166#define side_arg_dynamic_s32_be(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1167#define side_arg_dynamic_s64_be(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
f5e650d7 1168#define side_arg_dynamic_pointer_be(_val, _attr) _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
8bdd5c12
MD		 1169#define side_arg_dynamic_float_binary16_be(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1170#define side_arg_dynamic_float_binary32_be(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1171#define side_arg_dynamic_float_binary64_be(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1172#define side_arg_dynamic_float_binary128_be(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1173
8d20e708 1174#define side_arg_dynamic_vla(_vla) \
808bd9bf
MD		 1175 { \
1176 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA, \
808bd9bf
MD		 1177 .u = { \
1178 .side_dynamic_vla = (_vla), \
1179 }, \
1180 }
1181
1182#define side_arg_dynamic_vla_visitor(_dynamic_vla_visitor, _ctx, _attr) \
bdc39c09 1183 { \
1e8256c9 1184 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA_VISITOR, \
bdc39c09 1185 .u = { \
8ceca0cd
MD		 1186 .side_dynamic_vla_visitor = { \
1187 .app_ctx = _ctx, \
1188 .visitor = _dynamic_vla_visitor, \
8d20e708
MD		 1189 .attr = _attr, \
1190 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8ceca0cd 1191 }, \
bdc39c09
MD		 1192 }, \
1193 }
1194
8d20e708 1195#define side_arg_dynamic_struct(_struct) \
808bd9bf
MD		 1196 { \
1197 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT, \
808bd9bf
MD		 1198 .u = { \
1199 .side_dynamic_struct = (_struct), \
1200 }, \
1201 }
1202
1203#define side_arg_dynamic_struct_visitor(_dynamic_struct_visitor, _ctx, _attr) \
bdc39c09 1204 { \
1e8256c9 1205 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT_VISITOR, \
bdc39c09 1206 .u = { \
8ceca0cd
MD		 1207 .side_dynamic_struct_visitor = { \
1208 .app_ctx = _ctx, \
1209 .visitor = _dynamic_struct_visitor, \
8d20e708
MD		 1210 .attr = _attr, \
1211 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8ceca0cd 1212 }, \
bdc39c09
MD		 1213 }, \
1214 }
1215
8d20e708 1216#define side_arg_dynamic_define_vec(_identifier, _sav, _attr) \
a2e2357e
MD		 1217 const struct side_arg_dynamic_vec _identifier##_vec[] = { _sav }; \
1218 const struct side_arg_dynamic_vec_vla _identifier = { \
1219 .sav = _identifier##_vec, \
8d20e708 1220 .attr = _attr, \
a2e2357e 1221 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
8d20e708 1222 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
a2e2357e
MD		 1223 }
1224
8d20e708 1225#define side_arg_dynamic_define_struct(_identifier, _struct_fields, _attr) \
c208889e
MD		 1226 const struct side_arg_dynamic_event_field _identifier##_fields[] = { _struct_fields }; \
1227 const struct side_arg_dynamic_event_struct _identifier = { \
465e5e7e 1228 .fields = _identifier##_fields, \
8d20e708 1229 .attr = _attr, \
465e5e7e 1230 .len = SIDE_ARRAY_SIZE(_identifier##_fields), \
8d20e708 1231 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
465e5e7e
MD		 1232 }
1233
f611d0c3
MD		 1234#define side_arg_define_vec(_identifier, _sav) \
1235 const struct side_arg_vec _identifier##_vec[] = { _sav }; \
1236 const struct side_arg_vec_description _identifier = { \
1237 .sav = _identifier##_vec, \
1238 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
1239 }
a2e2357e 1240
465e5e7e
MD		 1241#define side_arg_dynamic_field(_name, _elem) \
1242 { \
1243 .field_name = _name, \
1244 .elem = _elem, \
1245 }
1246
f611d0c3
MD		 1247#define side_arg_list(...) __VA_ARGS__
1248
d4328528 1249#define side_define_enum(_identifier, _mappings, _attr) \
79f677ba
MD		 1250 const struct side_enum_mappings _identifier = { \
1251 .mappings = _mappings, \
d4328528 1252 .attr = _attr, \
79f677ba 1253 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
d4328528 1254 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
79f677ba
MD		 1255 }
1256
66cff328 1257#define side_enum_mapping_list(...) \
79f677ba
MD		 1258 SIDE_COMPOUND_LITERAL(const struct side_enum_mapping, __VA_ARGS__)
1259
1260#define side_enum_mapping_range(_label, _begin, _end) \
1261 { \
1262 .range_begin = _begin, \
1263 .range_end = _end, \
1264 .label = _label, \
1265 }
1266
1267#define side_enum_mapping_value(_label, _value) \
1268 { \
1269 .range_begin = _value, \
1270 .range_end = _value, \
1271 .label = _label, \
1272 }
1273
d4328528 1274#define side_define_enum_bitmap(_identifier, _mappings, _attr) \
66cff328
MD		 1275 const struct side_enum_bitmap_mappings _identifier = { \
1276 .mappings = _mappings, \
d4328528 1277 .attr = _attr, \
66cff328 1278 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
d4328528 1279 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
66cff328
MD		 1280 }
1281
1282#define side_enum_bitmap_mapping_list(...) \
1283 SIDE_COMPOUND_LITERAL(const struct side_enum_bitmap_mapping, __VA_ARGS__)
1284
1285#define side_enum_bitmap_mapping_range(_label, _begin, _end) \
1286 { \
1287 .range_begin = _begin, \
1288 .range_end = _end, \
1289 .label = _label, \
1290 }
1291
1292#define side_enum_bitmap_mapping_value(_label, _value) \
1293 { \
1294 .range_begin = _value, \
1295 .range_end = _value, \
1296 .label = _label, \
1297 }
1298
f85b7f8b
MD		 1299#define side_event_cond(_identifier) \
1300 if (side_unlikely(__atomic_load_n(&side_event_enable__##_identifier, \
1301 __ATOMIC_RELAXED)))
e24949fa 1302
89747802 1303#define side_event_call(_identifier, _sav) \
e24949fa
MD		 1304 { \
1305 const struct side_arg_vec side_sav[] = { _sav }; \
1306 const struct side_arg_vec_description sav_desc = { \
1307 .sav = side_sav, \
1308 .len = SIDE_ARRAY_SIZE(side_sav), \
1309 }; \
89747802 1310 side_call(&(_identifier), &sav_desc); \
e24949fa
MD		 1311 }
1312
89747802
MD		 1313#define side_event(_identifier, _sav) \
1314 side_event_cond(_identifier) \
1315 side_event_call(_identifier, SIDE_PARAM(_sav))
e24949fa 1316
89747802 1317#define side_event_call_variadic(_identifier, _sav, _var_fields, _attr) \
e24949fa
MD		 1318 { \
1319 const struct side_arg_vec side_sav[] = { _sav }; \
1320 const struct side_arg_vec_description sav_desc = { \
1321 .sav = side_sav, \
1322 .len = SIDE_ARRAY_SIZE(side_sav), \
1323 }; \
1324 const struct side_arg_dynamic_event_field side_fields[] = { _var_fields }; \
1325 const struct side_arg_dynamic_event_struct var_struct = { \
1326 .fields = side_fields, \
1327 .attr = _attr, \
1328 .len = SIDE_ARRAY_SIZE(side_fields), \
1329 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1330 }; \
89747802 1331 side_call_variadic(&(_identifier), &sav_desc, &var_struct); \
e24949fa
MD		 1332 }
1333
89747802
MD		 1334#define side_event_variadic(_identifier, _sav, _var, _attr) \
1335 side_event_cond(_identifier) \
1336 side_event_call_variadic(_identifier, SIDE_PARAM(_sav), SIDE_PARAM(_var), SIDE_PARAM(_attr))
e24949fa 1337
89747802 1338#define _side_define_event(_linkage, _identifier, _provider, _event, _loglevel, _fields, _attr, _flags) \
83a72806 1339 _linkage uintptr_t side_event_enable__##_identifier __attribute__((section("side_event_enable"))); \
89747802
MD		 1340 _linkage struct side_event_description __attribute__((section("side_event_description"))) \
1341 _identifier = { \
89747802 1342 .enabled = &(side_event_enable__##_identifier), \
f611d0c3
MD		 1343 .provider_name = _provider, \
1344 .event_name = _event, \
1345 .fields = _fields, \
65010f43 1346 .attr = _attr, \
054b7b5c 1347 .callbacks = &side_empty_callback, \
352df610
MD		 1348 .flags = (_flags), \
1349 .version = 0, \
1350 .loglevel = _loglevel, \
1351 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
1352 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1353 .nr_callbacks = 0, \
b5b67ff2 1354 }; \
89747802
MD		 1355 static const struct side_event_description *side_event_ptr__##_identifier \
1356 __attribute__((section("side_event_description_ptr"), used)) = &(_identifier);
1357
1358#define side_static_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1359 _side_define_event(static, _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1360 SIDE_PARAM(_attr), 0)
1361
1362#define side_static_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1363 _side_define_event(static, _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1364 SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
1365
1366#define side_hidden_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1367 _side_define_event(__attribute__((visibility("hidden"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1368 SIDE_PARAM(_attr), 0)
1369
1370#define side_hidden_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1371 _side_define_event(__attribute__((visibility("hidden"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1372 SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
f611d0c3 1373
89747802
MD		 1374#define side_export_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1375 _side_define_event(__attribute__((visibility("default"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
399c836b 1376 SIDE_PARAM(_attr), 0)
8a25ce77 1377
89747802
MD		 1378#define side_export_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1379 _side_define_event(__attribute__((visibility("default"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
399c836b 1380 SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
8a25ce77 1381
f611d0c3 1382#define side_declare_event(_identifier) \
83a72806 1383 extern uintptr_t side_event_enable_##_identifier; \
89747802 1384 extern struct side_event_description _identifier
f611d0c3 1385
a3f36db7
MD		 1386extern const struct side_callback side_empty_callback;
1387
6841ae81
MD		 1388void side_call(const struct side_event_description *desc,
1389 const struct side_arg_vec_description *sav_desc);
1390void side_call_variadic(const struct side_event_description *desc,
1391 const struct side_arg_vec_description *sav_desc,
1392 const struct side_arg_dynamic_event_struct *var_struct);
1393
a3f36db7
MD		 1394int side_tracer_callback_register(struct side_event_description *desc,
1395 void (*call)(const struct side_event_description *desc,
1396 const struct side_arg_vec_description *sav_desc,
1397 void *priv),
1398 void *priv);
1399int side_tracer_callback_variadic_register(struct side_event_description *desc,
1400 void (*call_variadic)(const struct side_event_description *desc,
1401 const struct side_arg_vec_description *sav_desc,
1402 const struct side_arg_dynamic_event_struct *var_struct,
1403 void *priv),
1404 void *priv);
1405int side_tracer_callback_unregister(struct side_event_description *desc,
1406 void (*call)(const struct side_event_description *desc,
1407 const struct side_arg_vec_description *sav_desc,
1408 void *priv),
1409 void *priv);
1410int side_tracer_callback_variadic_unregister(struct side_event_description *desc,
1411 void (*call_variadic)(const struct side_event_description *desc,
1412 const struct side_arg_vec_description *sav_desc,
1413 const struct side_arg_dynamic_event_struct *var_struct,
1414 void *priv),
1415 void *priv);
054b7b5c 1416
6e46f5e6
MD		 1417struct side_events_register_handle *side_events_register(struct side_event_description **events, uint32_t nr_events);
1418void side_events_unregister(struct side_events_register_handle *handle);
1419
a13c9d2e
MD		 1420enum side_tracer_notification {
1421 SIDE_TRACER_NOTIFICATION_INSERT_EVENTS,
1422 SIDE_TRACER_NOTIFICATION_REMOVE_EVENTS,
1423};
1424
1425/* Callback is invoked with side library internal lock held. */
1426struct side_tracer_handle *side_tracer_event_notification_register(
1427 void (*cb)(enum side_tracer_notification notif,
1428 struct side_event_description **events, uint32_t nr_events, void *priv),
1429 void *priv);
1430void side_tracer_event_notification_unregister(struct side_tracer_handle *handle);
1431
6e46f5e6
MD		 1432void side_init(void);
1433void side_exit(void);
1434
314c22c3
MD		 1435/*
1436 * These weak symbols, the constructor, and destructor take care of
1437 * registering only _one_ instance of the side instrumentation per
1438 * shared-ojbect (or for the whole main program).
1439 */
1440extern struct side_event_description * __start_side_event_description_ptr[]
1441 __attribute__((weak, visibility("hidden")));
1442extern struct side_event_description * __stop_side_event_description_ptr[]
1443 __attribute__((weak, visibility("hidden")));
1444int side_event_description_ptr_registered
1445 __attribute__((weak, visibility("hidden")));
1446struct side_events_register_handle *side_events_handle
1447 __attribute__((weak, visibility("hidden")));
1448
1449static void
1450side_event_description_ptr_init(void)
1451 __attribute__((no_instrument_function))
1452 __attribute__((constructor));
1453static void
1454side_event_description_ptr_init(void)
1455{
1456 if (side_event_description_ptr_registered++)
1457 return;
1458 side_events_handle = side_events_register(__start_side_event_description_ptr,
1459 __stop_side_event_description_ptr - __start_side_event_description_ptr);
1460}
1461
1462static void
1463side_event_description_ptr_exit(void)
1464 __attribute__((no_instrument_function))
1465 __attribute__((destructor));
1466static void
1467side_event_description_ptr_exit(void)
1468{
1469 if (--side_event_description_ptr_registered)
1470 return;
1471 side_events_unregister(side_events_handle);
1472 side_events_handle = NULL;
1473}
1474
f611d0c3 1475#endif /* _SIDE_TRACE_H */
Software Instrumentation Dynamically Enabled
This page took 0.099252 seconds and 4 git commands to generate.