projects / libside.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Move enabled state outside of event description
[libside.git] / include / side / trace.h
diff --git a/include/side/trace.h b/include/side/trace.h
index 8a9cfe17c826d5fc43230e391e22954bd3fbea9d..e3a53a343fd9dbec57e9e2e5d0986c6edc6f4826 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -40,6 +40,7 @@ enum side_type {
        SIDE_TYPE_S16,
        SIDE_TYPE_S32,
        SIDE_TYPE_S64,
+       SIDE_TYPE_BLOB,
 
        SIDE_TYPE_ENUM_U8,
        SIDE_TYPE_ENUM_U16,
@@ -75,6 +76,7 @@ enum side_type {
        SIDE_TYPE_ARRAY_S16,
        SIDE_TYPE_ARRAY_S32,
        SIDE_TYPE_ARRAY_S64,
+       SIDE_TYPE_ARRAY_BLOB,
 
        SIDE_TYPE_VLA_U8,
        SIDE_TYPE_VLA_U16,
@@ -84,6 +86,7 @@ enum side_type {
        SIDE_TYPE_VLA_S16,
        SIDE_TYPE_VLA_S32,
        SIDE_TYPE_VLA_S64,
+       SIDE_TYPE_VLA_BLOB,
 
        SIDE_TYPE_DYNAMIC,
 };
@@ -101,6 +104,7 @@ enum side_dynamic_type {
        SIDE_DYNAMIC_TYPE_S16,
        SIDE_DYNAMIC_TYPE_S32,
        SIDE_DYNAMIC_TYPE_S64,
+       SIDE_DYNAMIC_TYPE_BLOB,
 
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
@@ -257,7 +261,7 @@ enum side_event_flags {
 
 struct side_event_description {
        uint32_t version;
-       uint32_t enabled;
+       uint32_t *enabled;
        uint32_t loglevel;      /* enum side_loglevel */
        uint32_t nr_fields;
        uint32_t nr_attr;
@@ -289,6 +293,7 @@ struct side_arg_dynamic_vec {
                int16_t side_s16;
                int32_t side_s32;
                int64_t side_s64;
+               uint8_t side_blob;
 
 #if __HAVE_FLOAT16
                _Float16 side_float_binary16;
@@ -342,6 +347,7 @@ struct side_arg_vec {
                int16_t side_s16;
                int32_t side_s32;
                int64_t side_s64;
+               uint8_t side_blob;
 
 #if __HAVE_FLOAT16
                _Float16 side_float_binary16;
@@ -408,20 +414,54 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_attr_list(...) \
        SIDE_COMPOUND_LITERAL(const struct side_attr, __VA_ARGS__)
 
-#define side_type_decl(_type, _attr) \
+#define _side_type(_type, _attr) \
        { \
                .type = _type, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
                .attr = _attr, \
        }
 
-#define side_field(_name, _type, _attr) \
+#define side_type_bool(_attr)                          _side_type(SIDE_TYPE_BOOL, SIDE_PARAM(_attr))
+#define side_type_u8(_attr)                            _side_type(SIDE_TYPE_U8, SIDE_PARAM(_attr))
+#define side_type_u16(_attr)                           _side_type(SIDE_TYPE_U16, SIDE_PARAM(_attr))
+#define side_type_u32(_attr)                           _side_type(SIDE_TYPE_U32, SIDE_PARAM(_attr))
+#define side_type_u64(_attr)                           _side_type(SIDE_TYPE_U64, SIDE_PARAM(_attr))
+#define side_type_s8(_attr)                            _side_type(SIDE_TYPE_S8, SIDE_PARAM(_attr))
+#define side_type_s16(_attr)                           _side_type(SIDE_TYPE_S16, SIDE_PARAM(_attr))
+#define side_type_s32(_attr)                           _side_type(SIDE_TYPE_S32, SIDE_PARAM(_attr))
+#define side_type_s64(_attr)                           _side_type(SIDE_TYPE_S64, SIDE_PARAM(_attr))
+#define side_type_blob(_attr)                          _side_type(SIDE_TYPE_BLOB, SIDE_PARAM(_attr))
+#define side_type_float_binary16(_attr)                        _side_type(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
+#define side_type_float_binary32(_attr)                        _side_type(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
+#define side_type_float_binary64(_attr)                        _side_type(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
+#define side_type_float_binary128(_attr)               _side_type(SIDE_TYPE_FLOAT_BINARY128, SIDE_PARAM(_attr))
+#define side_type_string(_attr)                                _side_type(SIDE_TYPE_STRING, SIDE_PARAM(_attr))
+#define side_type_dynamic(_attr)                       _side_type(SIDE_TYPE_DYNAMIC, SIDE_PARAM(_attr))
+
+#define _side_field(_name, _type) \
        { \
                .field_name = _name, \
-               .side_type = side_type_decl(_type, SIDE_PARAM(_attr)), \
-       }
-
-#define side_type_enum_decl(_type, _mappings, _attr) \
+               .side_type = _type, \
+       }
+
+#define side_field_bool(_name, _attr)                  _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
+#define side_field_u8(_name, _attr)                    _side_field(_name, side_type_u8(SIDE_PARAM(_attr)))
+#define side_field_u16(_name, _attr)                   _side_field(_name, side_type_u16(SIDE_PARAM(_attr)))
+#define side_field_u32(_name, _attr)                   _side_field(_name, side_type_u32(SIDE_PARAM(_attr)))
+#define side_field_u64(_name, _attr)                   _side_field(_name, side_type_u64(SIDE_PARAM(_attr)))
+#define side_field_s8(_name, _attr)                    _side_field(_name, side_type_s8(SIDE_PARAM(_attr)))
+#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_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)))
+#define side_field_float_binary128(_name, _attr)       _side_field(_name, side_type_float_binary128(SIDE_PARAM(_attr)))
+#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(_type, _mappings, _attr) \
        { \
                .type = _type, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
@@ -430,13 +470,27 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                        .side_enum_mappings = _mappings, \
                }, \
        }
-#define side_field_enum(_name, _type, _mappings, _attr) \
-       { \
-               .field_name = _name, \
-               .side_type = side_type_enum_decl(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)), \
-       }
-
-#define side_type_enum_bitmap_decl(_type, _mappings, _attr) \
+#define _side_field_enum(_name, _type, _mappings, _attr) \
+       _side_field(_name, side_type_enum(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)))
+
+#define side_field_enum_u8(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_u16(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_u32(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_u64(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_s8(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_s16(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_s32(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_s64(_name, _mappings, _attr) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+
+#define side_type_enum_bitmap(_type, _mappings, _attr) \
        { \
                .type = _type, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
@@ -445,13 +499,19 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                        .side_enum_bitmap_mappings = _mappings, \
                }, \
        }
-#define side_field_enum_bitmap(_name, _type, _mappings, _attr) \
-       { \
-               .field_name = _name, \
-               .side_type = side_type_enum_bitmap_decl(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)), \
-       }
+#define _side_field_enum_bitmap(_name, _type, _mappings, _attr) \
+       _side_field(_name, side_type_enum_bitmap(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)))
+
+#define side_field_enum_bitmap8(_name, _mappings, _attr) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_bitmap16(_name, _mappings, _attr) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_bitmap32(_name, _mappings, _attr) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define side_field_enum_bitmap64(_name, _mappings, _attr) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
 
-#define side_type_struct_decl(_fields, _attr) \
+#define side_type_struct(_fields, _attr) \
        { \
                .type = SIDE_TYPE_STRUCT, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
@@ -464,12 +524,9 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 #define side_field_struct(_name, _fields, _attr) \
-       { \
-               .field_name = _name, \
-               .side_type = side_type_struct_decl(SIDE_PARAM(_fields), SIDE_PARAM(_attr)), \
-       }
+       _side_field(_name, side_type_struct(SIDE_PARAM(_fields), SIDE_PARAM(_attr)))
 
-#define side_type_array_decl(_elem_type, _length, _attr) \
+#define side_type_array(_elem_type, _length, _attr) \
        { \
                .type = SIDE_TYPE_ARRAY, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
@@ -482,12 +539,9 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 #define side_field_array(_name, _elem_type, _length, _attr) \
-       { \
-               .field_name = _name, \
-               .side_type = side_type_array_decl(SIDE_PARAM(_elem_type), _length, SIDE_PARAM(_attr)), \
-       }
+       _side_field(_name, side_type_array(SIDE_PARAM(_elem_type), _length, SIDE_PARAM(_attr)))
 
-#define side_type_vla_decl(_elem_type, _attr) \
+#define side_type_vla(_elem_type, _attr) \
        { \
                .type = SIDE_TYPE_VLA, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
@@ -499,12 +553,9 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 #define side_field_vla(_name, _elem_type, _attr) \
-       { \
-               .field_name = _name, \
-               .side_type = side_type_vla_decl(SIDE_PARAM(_elem_type), SIDE_PARAM(_attr)), \
-       }
+       _side_field(_name, side_type_vla(SIDE_PARAM(_elem_type), SIDE_PARAM(_attr)))
 
-#define side_type_vla_visitor_decl(_elem_type, _visitor, _attr) \
+#define side_type_vla_visitor(_elem_type, _visitor, _attr) \
        { \
                .type = SIDE_TYPE_VLA_VISITOR, \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
@@ -517,17 +568,11 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 #define side_field_vla_visitor(_name, _elem_type, _visitor, _attr) \
-       { \
-               .field_name = _name, \
-               .side_type = side_type_vla_visitor_decl(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)), \
-       }
+       _side_field(_name, side_type_vla_visitor(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)))
 
 #define side_elem(...) \
        SIDE_COMPOUND_LITERAL(const struct side_type_description, __VA_ARGS__)
 
-#define side_elem_type(_type, _attr) \
-       side_elem(side_type_decl(_type, SIDE_PARAM(_attr)))
-
 #define side_field_list(...) \
        SIDE_COMPOUND_LITERAL(const struct side_event_field, __VA_ARGS__)
 
@@ -540,6 +585,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_enum_u8(val)          { .type = SIDE_TYPE_ENUM_U8, .u = { .side_u8 = (val) } }
 #define side_arg_enum_u16(val)         { .type = SIDE_TYPE_ENUM_U16, .u = { .side_u16 = (val) } }
 #define side_arg_enum_u32(val)         { .type = SIDE_TYPE_ENUM_U32, .u = { .side_u32 = (val) } }
@@ -571,6 +617,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_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) } } }
@@ -580,6 +627,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_dynamic(dynamic_arg_type) \
        { \
@@ -679,6 +727,15 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                        .side_s64 = (_val), \
                }, \
        }
+#define side_arg_dynamic_blob(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_BLOB, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_blob = (_val), \
+               }, \
+       }
 
 #define side_arg_dynamic_float_binary16(_val, _attr) \
        { \
@@ -817,23 +874,23 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_attr_float_binary128(val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY128, .u = { .side_float_binary128 = (val) } }
 #define side_attr_string(val)          { .type = SIDE_ATTR_TYPE_STRING, .u = { .string = (val) } }
 
-#define side_event_cond(desc) if (side_unlikely((desc)->enabled))
+#define side_event_cond(_desc) if (side_unlikely(_desc##_enabled))
 
-#define side_event_call(desc, _sav) \
+#define side_event_call(_desc, _sav) \
        { \
                const struct side_arg_vec side_sav[] = { _sav }; \
                const struct side_arg_vec_description sav_desc = { \
                        .sav = side_sav, \
                        .len = SIDE_ARRAY_SIZE(side_sav), \
                }; \
-               side_call(desc, &sav_desc); \
+               side_call(&(_desc), &sav_desc); \
        }
 
-#define side_event(desc, sav) \
-       side_event_cond(desc) \
-               side_event_call(desc, SIDE_PARAM(sav))
+#define side_event(_desc, _sav) \
+       side_event_cond(_desc) \
+               side_event_call(_desc, SIDE_PARAM(_sav))
 
-#define side_event_call_variadic(desc, _sav, _var_fields) \
+#define side_event_call_variadic(_desc, _sav, _var_fields) \
        { \
                const struct side_arg_vec side_sav[] = { _sav }; \
                const struct side_arg_vec_description sav_desc = { \
@@ -845,12 +902,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                        .fields = side_fields, \
                        .len = SIDE_ARRAY_SIZE(side_fields), \
                }; \
-               side_call_variadic(desc, &sav_desc, &var_struct); \
+               side_call_variadic(&(_desc), &sav_desc, &var_struct); \
        }
 
-#define side_event_variadic(desc, sav, var) \
-       side_event_cond(desc) \
-               side_event_call_variadic(desc, SIDE_PARAM(sav), SIDE_PARAM(var))
+#define side_event_variadic(_desc, _sav, _var) \
+       side_event_cond(_desc) \
+               side_event_call_variadic(_desc, SIDE_PARAM(_sav), SIDE_PARAM(_var))
 
 #define side_define_enum(_identifier, _mappings) \
        const struct side_enum_mappings _identifier = { \
@@ -899,9 +956,10 @@ struct side_tracer_dynamic_vla_visitor_ctx {
        }
 
 #define _side_define_event(_identifier, _provider, _event, _loglevel, _fields, _attr, _flags) \
-       struct side_event_description _identifier = { \
+       uint32_t _identifier##_enabled; \
+       const struct side_event_description _identifier = { \
                .version = 0, \
-               .enabled = 0, \
+               .enabled = &_identifier##_enabled, \
                .loglevel = _loglevel, \
                .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
Software Instrumentation Dynamically Enabled
This page took 0.027567 seconds and 4 git commands to generate.