X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Ffs-sink%2Ffs-sink-ctf-meta.h;h=d525faa8a914361054a332e1b0b452f607a70750;hb=b8ddb4f036272e30030202637201d11baf5f20a5;hp=7585ac745735c5f75a97aa1e9c76c4fd42405303;hpb=cd03c43c9c60177a6b0cb2496a784bfefca9740f;p=babeltrace.git diff --git a/src/plugins/ctf/fs-sink/fs-sink-ctf-meta.h b/src/plugins/ctf/fs-sink/fs-sink-ctf-meta.h index 7585ac74..d525faa8 100644 --- a/src/plugins/ctf/fs-sink/fs-sink-ctf-meta.h +++ b/src/plugins/ctf/fs-sink/fs-sink-ctf-meta.h @@ -18,7 +18,7 @@ #include #include "common/common.h" #include "common/assert.h" -#include "compat/uuid.h" +#include "common/uuid.h" #include #include #include @@ -26,12 +26,15 @@ #include enum fs_sink_ctf_field_class_type { + FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL, + FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY, FS_SINK_CTF_FIELD_CLASS_TYPE_INT, FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT, FS_SINK_CTF_FIELD_CLASS_TYPE_STRING, FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT, FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY, FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE, + FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION, FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT, }; @@ -52,6 +55,10 @@ struct fs_sink_ctf_field_class_bit_array { unsigned int size; }; +struct fs_sink_ctf_field_class_bool { + struct fs_sink_ctf_field_class_bit_array base; +}; + struct fs_sink_ctf_field_class_int { struct fs_sink_ctf_field_class_bit_array base; bool is_signed; @@ -79,6 +86,12 @@ struct fs_sink_ctf_field_class_struct { GArray *members; }; +struct fs_sink_ctf_field_class_option { + struct fs_sink_ctf_field_class base; + struct fs_sink_ctf_field_class *content_fc; + GString *tag_ref; +}; + struct fs_sink_ctf_field_class_variant { struct fs_sink_ctf_field_class base; GString *tag_ref; @@ -133,6 +146,7 @@ struct fs_sink_ctf_stream_class { const bt_clock_class *default_clock_class; GString *default_clock_class_name; + bool has_packets; bool packets_have_ts_begin; bool packets_have_ts_end; bool has_discarded_events; @@ -162,7 +176,7 @@ struct fs_sink_ctf_trace { /* Weak */ const bt_trace_class *ir_tc; - unsigned char uuid[BABELTRACE_UUID_LEN]; + bt_uuid_t uuid; /* Array of `struct fs_sink_ctf_stream_class *` (owned by this) */ GPtrArray *stream_classes; @@ -235,6 +249,41 @@ void _fs_sink_ctf_named_field_class_fini( named_fc->fc = NULL; } +static inline +struct fs_sink_ctf_field_class_bit_array * +fs_sink_ctf_field_class_bit_array_create( + const bt_field_class *ir_fc, uint64_t index_in_parent) +{ + struct fs_sink_ctf_field_class_bit_array *fc = + g_new0(struct fs_sink_ctf_field_class_bit_array, 1); + + BT_ASSERT(fc); + _fs_sink_ctf_field_class_bit_array_init((void *) fc, + FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY, ir_fc, + (unsigned int) bt_field_class_bit_array_get_length(ir_fc), + index_in_parent); + return fc; +} + +static inline +struct fs_sink_ctf_field_class_bool *fs_sink_ctf_field_class_bool_create( + const bt_field_class *ir_fc, uint64_t index_in_parent) +{ + struct fs_sink_ctf_field_class_bool *fc = + g_new0(struct fs_sink_ctf_field_class_bool, 1); + + BT_ASSERT(fc); + + /* + * CTF 1.8 has no boolean field class type, so this component + * translates it to an 8-bit unsigned integer field class. + */ + _fs_sink_ctf_field_class_bit_array_init((void *) fc, + FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL, ir_fc, + 8, index_in_parent); + return fc; +} + static inline struct fs_sink_ctf_field_class_int *fs_sink_ctf_field_class_int_create( const bt_field_class *ir_fc, uint64_t index_in_parent) @@ -258,7 +307,8 @@ struct fs_sink_ctf_field_class_float *fs_sink_ctf_field_class_float_create( BT_ASSERT(fc); _fs_sink_ctf_field_class_bit_array_init((void *) fc, FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT, - ir_fc, bt_field_class_real_is_single_precision(ir_fc) ? 32 : 64, + ir_fc, + bt_field_class_get_type(ir_fc) == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL ? 32 : 64, index_in_parent); return fc; } @@ -293,6 +343,22 @@ struct fs_sink_ctf_field_class_struct *fs_sink_ctf_field_class_struct_create_emp return fc; } +static inline +struct fs_sink_ctf_field_class_option *fs_sink_ctf_field_class_option_create_empty( + const bt_field_class *ir_fc, uint64_t index_in_parent) +{ + struct fs_sink_ctf_field_class_option *fc = + g_new0(struct fs_sink_ctf_field_class_option, 1); + + BT_ASSERT(fc); + _fs_sink_ctf_field_class_init((void *) fc, + FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION, ir_fc, + 1, index_in_parent); + fc->tag_ref = g_string_new(NULL); + BT_ASSERT(fc->tag_ref); + return fc; +} + static inline struct fs_sink_ctf_field_class_variant *fs_sink_ctf_field_class_variant_create_empty( const bt_field_class *ir_fc, uint64_t index_in_parent) @@ -310,8 +376,8 @@ struct fs_sink_ctf_field_class_variant *fs_sink_ctf_field_class_variant_create_e fc->tag_ref = g_string_new(NULL); BT_ASSERT(fc->tag_ref); fc->tag_is_before = - bt_field_class_variant_borrow_selector_field_path_const(ir_fc) == - NULL; + bt_field_class_get_type(fc->base.ir_fc) == + BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR; return fc; } @@ -326,7 +392,7 @@ struct fs_sink_ctf_field_class_array *fs_sink_ctf_field_class_array_create_empty _fs_sink_ctf_field_class_init((void *) fc, FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY, ir_fc, 1, index_in_parent); - fc->length = bt_field_class_static_array_get_length(ir_fc); + fc->length = bt_field_class_array_static_get_length(ir_fc); return fc; } @@ -344,8 +410,8 @@ struct fs_sink_ctf_field_class_sequence *fs_sink_ctf_field_class_sequence_create fc->length_ref = g_string_new(NULL); BT_ASSERT(fc->length_ref); fc->length_is_before = - bt_field_class_dynamic_array_borrow_length_field_path_const(ir_fc) == - NULL; + bt_field_class_get_type(ir_fc) == + BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD; return fc; } @@ -365,6 +431,24 @@ void _fs_sink_ctf_field_class_fini(struct fs_sink_ctf_field_class *fc) BT_ASSERT(fc); } +static inline +void _fs_sink_ctf_field_class_bit_array_destroy( + struct fs_sink_ctf_field_class_int *fc) +{ + BT_ASSERT(fc); + _fs_sink_ctf_field_class_fini((void *) fc); + g_free(fc); +} + +static inline +void _fs_sink_ctf_field_class_bool_destroy( + struct fs_sink_ctf_field_class_int *fc) +{ + BT_ASSERT(fc); + _fs_sink_ctf_field_class_fini((void *) fc); + g_free(fc); +} + static inline void _fs_sink_ctf_field_class_int_destroy( struct fs_sink_ctf_field_class_int *fc) @@ -451,6 +535,22 @@ void _fs_sink_ctf_field_class_sequence_destroy( g_free(fc); } +static inline +void _fs_sink_ctf_field_class_option_destroy( + struct fs_sink_ctf_field_class_option *fc) +{ + BT_ASSERT(fc); + _fs_sink_ctf_field_class_fini((void *) fc); + fs_sink_ctf_field_class_destroy(fc->content_fc); + + if (fc->tag_ref) { + g_string_free(fc->tag_ref, TRUE); + fc->tag_ref = NULL; + } + + g_free(fc); +} + static inline void _fs_sink_ctf_field_class_variant_destroy( struct fs_sink_ctf_field_class_variant *fc) @@ -489,6 +589,12 @@ void fs_sink_ctf_field_class_destroy(struct fs_sink_ctf_field_class *fc) } switch (fc->type) { + case FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL: + _fs_sink_ctf_field_class_bool_destroy((void *) fc); + break; + case FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY: + _fs_sink_ctf_field_class_bit_array_destroy((void *) fc); + break; case FS_SINK_CTF_FIELD_CLASS_TYPE_INT: _fs_sink_ctf_field_class_int_destroy((void *) fc); break; @@ -507,6 +613,9 @@ void fs_sink_ctf_field_class_destroy(struct fs_sink_ctf_field_class *fc) case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE: _fs_sink_ctf_field_class_sequence_destroy((void *) fc); break; + case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION: + _fs_sink_ctf_field_class_option_destroy((void *) fc); + break; case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT: _fs_sink_ctf_field_class_variant_destroy((void *) fc); break; @@ -739,6 +848,7 @@ struct fs_sink_ctf_stream_class *fs_sink_ctf_stream_class_create( sc->event_classes_from_ir = g_hash_table_new(g_direct_hash, g_direct_equal); BT_ASSERT(sc->event_classes_from_ir); + sc->has_packets = bt_stream_class_supports_packets(ir_sc); sc->packets_have_ts_begin = bt_stream_class_packets_have_beginning_default_clock_snapshot( ir_sc); @@ -823,11 +933,7 @@ struct fs_sink_ctf_trace *fs_sink_ctf_trace_create(const bt_trace *ir_trace) BT_ASSERT(trace); - if (bt_uuid_generate(trace->uuid)) { - fs_sink_ctf_trace_destroy(trace); - trace = NULL; - goto end; - } + bt_uuid_generate(trace->uuid); trace->ir_trace = ir_trace; trace->ir_tc = bt_trace_borrow_class_const(ir_trace); @@ -835,95 +941,7 @@ struct fs_sink_ctf_trace *fs_sink_ctf_trace_create(const bt_trace *ir_trace) (GDestroyNotify) fs_sink_ctf_stream_class_destroy); BT_ASSERT(trace->stream_classes); -end: return trace; } -static inline -bool fs_sink_ctf_ist_valid_identifier(const char *name) -{ - const char *at; - uint64_t i; - bool ist_valid = true; - static const char *reserved_keywords[] = { - "align", - "callsite", - "const", - "char", - "clock", - "double", - "enum", - "env", - "event", - "floating_point", - "float", - "integer", - "int", - "long", - "short", - "signed", - "stream", - "string", - "struct", - "trace", - "typealias", - "typedef", - "unsigned", - "variant", - "void", - "_Bool", - "_Complex", - "_Imaginary", - }; - - /* Make sure the name is not a reserved keyword */ - for (i = 0; i < sizeof(reserved_keywords) / sizeof(*reserved_keywords); - i++) { - if (strcmp(name, reserved_keywords[i]) == 0) { - ist_valid = false; - goto end; - } - } - - /* Make sure the name is not an empty string */ - if (strlen(name) == 0) { - ist_valid = false; - goto end; - } - - /* Make sure the name starts with a letter or `_` */ - if (!isalpha(name[0]) && name[0] != '_') { - ist_valid = false; - goto end; - } - - /* Make sure the name only contains letters, digits, and `_` */ - for (at = name; *at != '\0'; at++) { - if (!isalnum(*at) && *at != '_') { - ist_valid = false; - goto end; - } - } - -end: - return ist_valid; -} - -static inline -int fs_sink_ctf_protect_name(GString *name) -{ - int ret = 0; - - if (!fs_sink_ctf_ist_valid_identifier(name->str)) { - ret = -1; - goto end; - } - - /* Prepend `_` to protect it */ - g_string_prepend_c(name, '_'); - -end: - return ret; -} - #endif /* BABELTRACE_PLUGIN_CTF_FS_SINK_FS_SINK_CTF_META_H */