Update rcu comment

[libside.git] / include / side / trace.h

diff --git a/include/side/trace.h b/include/side/trace.h
index bc5fa940ab2e5a698034f6fd240126e59eca85ca..f09463d7f7e1bcd5ade93ea8a05b63bc46fad729 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -42,7 +42,7 @@ enum side_type {
        SIDE_TYPE_S16,
        SIDE_TYPE_S32,
        SIDE_TYPE_S64,
-       SIDE_TYPE_BLOB,
+       SIDE_TYPE_BYTE,
        SIDE_TYPE_FLOAT_BINARY16,
        SIDE_TYPE_FLOAT_BINARY32,
        SIDE_TYPE_FLOAT_BINARY64,
@@ -63,7 +63,7 @@ enum side_type {
        SIDE_TYPE_ARRAY_S16,
        SIDE_TYPE_ARRAY_S32,
        SIDE_TYPE_ARRAY_S64,
-       SIDE_TYPE_ARRAY_BLOB,
+       SIDE_TYPE_ARRAY_BYTE,
 
        SIDE_TYPE_VLA_U8,
        SIDE_TYPE_VLA_U16,
@@ -73,18 +73,11 @@ enum side_type {
        SIDE_TYPE_VLA_S16,
        SIDE_TYPE_VLA_S32,
        SIDE_TYPE_VLA_S64,
-       SIDE_TYPE_VLA_BLOB,
+       SIDE_TYPE_VLA_BYTE,
 
        /* Enumeration types */
        SIDE_TYPE_ENUM,
-
-       SIDE_TYPE_ENUM_BITMAP8,
-       SIDE_TYPE_ENUM_BITMAP16,
-       SIDE_TYPE_ENUM_BITMAP32,
-       SIDE_TYPE_ENUM_BITMAP64,
-
-       SIDE_TYPE_ENUM_BITMAP_ARRAY,
-       SIDE_TYPE_ENUM_BITMAP_VLA,
+       SIDE_TYPE_ENUM_BITMAP,
 
        /* Dynamic type */
        SIDE_TYPE_DYNAMIC,
@@ -102,7 +95,7 @@ enum side_dynamic_type {
        SIDE_DYNAMIC_TYPE_S16,
        SIDE_DYNAMIC_TYPE_S32,
        SIDE_DYNAMIC_TYPE_S64,
-       SIDE_DYNAMIC_TYPE_BLOB,
+       SIDE_DYNAMIC_TYPE_BYTE,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY64,
@@ -257,20 +250,13 @@ struct side_type_description {
 
                /* Enumeration types */
                struct {
-                       const struct side_type_description *elem_type;
                        const struct side_enum_mappings *mappings;
+                       const struct side_type_description *elem_type;
                } side_enum;
-
-               const struct side_enum_bitmap_mappings *side_enum_bitmap_mappings;
                struct {
-                       const struct side_type_description *elem_type;
                        const struct side_enum_bitmap_mappings *mappings;
-                       uint32_t length;
-               } side_enum_bitmap_array;
-               struct {
                        const struct side_type_description *elem_type;
-                       const struct side_enum_bitmap_mappings *mappings;
-               } side_enum_bitmap_vla;
+               } side_enum_bitmap;
        } u;
 };
 
@@ -333,7 +319,7 @@ struct side_arg_dynamic_vec {
                                int16_t side_s16;
                                int32_t side_s32;
                                int64_t side_s64;
-                               uint8_t side_blob;
+                               uint8_t side_byte;
 #if __HAVE_FLOAT16
                                _Float16 side_float_binary16;
 #endif
@@ -400,7 +386,7 @@ struct side_arg_vec {
                int16_t side_s16;
                int32_t side_s32;
                int64_t side_s64;
-               uint8_t side_blob;
+               uint8_t side_byte;
 #if __HAVE_FLOAT16
                _Float16 side_float_binary16;
 #endif
@@ -506,7 +492,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_type_s16(_attr)                           _side_type_basic(SIDE_TYPE_S16, SIDE_PARAM(_attr))
 #define side_type_s32(_attr)                           _side_type_basic(SIDE_TYPE_S32, SIDE_PARAM(_attr))
 #define side_type_s64(_attr)                           _side_type_basic(SIDE_TYPE_S64, SIDE_PARAM(_attr))
-#define side_type_blob(_attr)                          _side_type_basic(SIDE_TYPE_BLOB, SIDE_PARAM(_attr))
+#define side_type_byte(_attr)                          _side_type_basic(SIDE_TYPE_BYTE, SIDE_PARAM(_attr))
 #define side_type_float_binary16(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
 #define side_type_float_binary32(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
 #define side_type_float_binary64(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
@@ -529,7 +515,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_s16(_name, _attr)                   _side_field(_name, side_type_s16(SIDE_PARAM(_attr)))
 #define side_field_s32(_name, _attr)                   _side_field(_name, side_type_s32(SIDE_PARAM(_attr)))
 #define side_field_s64(_name, _attr)                   _side_field(_name, side_type_s64(SIDE_PARAM(_attr)))
-#define side_field_blob(_name, _attr)                  _side_field(_name, side_type_blob(SIDE_PARAM(_attr)))
+#define side_field_byte(_name, _attr)                  _side_field(_name, side_type_byte(SIDE_PARAM(_attr)))
 #define side_field_float_binary16(_name, _attr)                _side_field(_name, side_type_float_binary16(SIDE_PARAM(_attr)))
 #define side_field_float_binary32(_name, _attr)                _side_field(_name, side_type_float_binary32(SIDE_PARAM(_attr)))
 #define side_field_float_binary64(_name, _attr)                _side_field(_name, side_type_float_binary64(SIDE_PARAM(_attr)))
@@ -537,72 +523,31 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_string(_name, _attr)                        _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
 #define side_field_dynamic(_name, _attr)               _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
 
-#define side_type_enum(_elem_type, _mappings) \
+#define side_type_enum(_mappings, _elem_type) \
        { \
                .type = SIDE_TYPE_ENUM, \
                .u = { \
                        .side_enum = { \
-                               .elem_type = _elem_type, \
                                .mappings = _mappings, \
-                       }, \
-               }, \
-       }
-#define side_field_enum(_name, _elem_type, _mappings) \
-       _side_field(_name, side_type_enum(SIDE_PARAM(_elem_type), SIDE_PARAM(_mappings)))
-
-#define side_type_enum_bitmap(_type, _mappings) \
-       { \
-               .type = _type, \
-               .u = { \
-                       .side_enum_bitmap_mappings = _mappings, \
-               }, \
-       }
-#define side_type_enum_bitmap8(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP8, SIDE_PARAM(_mappings))
-#define side_type_enum_bitmap16(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP16, SIDE_PARAM(_mappings))
-#define side_type_enum_bitmap32(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP32, SIDE_PARAM(_mappings))
-#define side_type_enum_bitmap64(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP64, SIDE_PARAM(_mappings))
-
-#define _side_field_enum_bitmap(_name, _type)  _side_field(_name, SIDE_PARAM(_type))
-
-#define side_field_enum_bitmap8(_name, _mappings) \
-       _side_field_enum_bitmap(_name, side_type_enum_bitmap8(SIDE_PARAM(_mappings)))
-#define side_field_enum_bitmap16(_name, _mappings) \
-       _side_field_enum_bitmap(_name, side_type_enum_bitmap16(SIDE_PARAM(_mappings)))
-#define side_field_enum_bitmap32(_name, _mappings) \
-       _side_field_enum_bitmap(_name, side_type_enum_bitmap32(SIDE_PARAM(_mappings)))
-#define side_field_enum_bitmap64(_name, _mappings) \
-       _side_field_enum_bitmap(_name, side_type_enum_bitmap64(SIDE_PARAM(_mappings)))
-
-#define side_type_enum_bitmap_array(_mappings, _elem_type, _length) \
-       { \
-               .type = SIDE_TYPE_ENUM_BITMAP_ARRAY, \
-               .u = { \
-                       .side_enum_bitmap_array = { \
                                .elem_type = _elem_type, \
-                               .mappings = _mappings, \
-                               .length = _length, \
                        }, \
                }, \
        }
-#define side_field_enum_bitmap_array(_name, _mappings, _elem_type, _length) \
-       _side_field(_name, side_type_enum_bitmap_array(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type), _length))
+#define side_field_enum(_name, _mappings, _elem_type) \
+       _side_field(_name, side_type_enum(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
 
-#define side_type_enum_bitmap_vla(_mappings, _elem_type) \
+#define side_type_enum_bitmap(_mappings, _elem_type) \
        { \
-               .type = SIDE_TYPE_ENUM_BITMAP_VLA, \
+               .type = SIDE_TYPE_ENUM_BITMAP, \
                .u = { \
-                       .side_enum_bitmap_vla = { \
-                               .elem_type = _elem_type, \
+                       .side_enum_bitmap = { \
                                .mappings = _mappings, \
+                               .elem_type = _elem_type, \
                        }, \
                }, \
        }
-#define side_field_enum_bitmap_vla(_name, _mappings, _elem_type) \
-       _side_field(_name, side_type_enum_bitmap_vla(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
+#define side_field_enum_bitmap(_name, _mappings, _elem_type) \
+       _side_field(_name, side_type_enum_bitmap(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
 
 #define side_type_struct(_struct) \
        { \
@@ -690,7 +635,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_s16(_val)             { .type = SIDE_TYPE_S16, .u = { .side_s16 = (_val) } }
 #define side_arg_s32(_val)             { .type = SIDE_TYPE_S32, .u = { .side_s32 = (_val) } }
 #define side_arg_s64(_val)             { .type = SIDE_TYPE_S64, .u = { .side_s64 = (_val) } }
-#define side_arg_blob(_val)            { .type = SIDE_TYPE_BLOB, .u = { .side_blob = (_val) } }
+#define side_arg_byte(_val)            { .type = SIDE_TYPE_BYTE, .u = { .side_byte = (_val) } }
 #define side_arg_enum_bitmap8(_val)    { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .side_u8 = (_val) } }
 #define side_arg_enum_bitmap16(_val)   { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .side_u16 = (_val) } }
 #define side_arg_enum_bitmap32(_val)   { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .side_u32 = (_val) } }
@@ -716,7 +661,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_array_s16(_ptr)       { .type = SIDE_TYPE_ARRAY_S16, .u = { .side_array_fixint  = (_ptr) } }
 #define side_arg_array_s32(_ptr)       { .type = SIDE_TYPE_ARRAY_S32, .u = { .side_array_fixint = (_ptr) } }
 #define side_arg_array_s64(_ptr)       { .type = SIDE_TYPE_ARRAY_S64, .u = { .side_array_fixint = (_ptr) } }
-#define side_arg_array_blob(_ptr)      { .type = SIDE_TYPE_ARRAY_BLOB, .u = { .side_array_fixint = (_ptr) } }
+#define side_arg_array_byte(_ptr)      { .type = SIDE_TYPE_ARRAY_BYTE, .u = { .side_array_fixint = (_ptr) } }
 
 #define side_arg_vla_u8(_ptr, _length) { .type = SIDE_TYPE_VLA_U8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } }
 #define side_arg_vla_u16(_ptr, _length)        { .type = SIDE_TYPE_VLA_U16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
@@ -726,7 +671,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_vla_s16(_ptr, _length)        { .type = SIDE_TYPE_VLA_S16, .u = { .side_vla_fixint  = { .p = (_ptr), .length = (_length) } } }
 #define side_arg_vla_s32(_ptr, _length)        { .type = SIDE_TYPE_VLA_S32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 #define side_arg_vla_s64(_ptr, _length)        { .type = SIDE_TYPE_VLA_S64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
-#define side_arg_vla_blob(_ptr, _length) { .type = SIDE_TYPE_VLA_BLOB, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
+#define side_arg_vla_byte(_ptr, _length) { .type = SIDE_TYPE_VLA_BYTE, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 
 #define side_arg_dynamic(_dynamic_arg_type) \
        { \
@@ -868,15 +813,15 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                        }, \
                }, \
        }
-#define side_arg_dynamic_blob(_val, _attr) \
+#define side_arg_dynamic_byte(_val, _attr) \
        { \
-               .dynamic_type = SIDE_DYNAMIC_TYPE_BLOB, \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_BYTE, \
                .u = { \
                        .side_basic = { \
                                .attr = _attr, \
                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
                                .u = { \
-                                       .side_blob = (_val), \
+                                       .side_byte = (_val), \
                                }, \
                        }, \
                }, \