X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream-class.c;h=b5e7e79dca12b2f7330a68ee838101a1da6f4b89;hb=09840de5d022697671dafe2bed427fa5c09b40b9;hp=573fb421ebfe6c26e37df2f8b0bf36b8a4fc384d;hpb=83509119a945fc77faff869daaf48627e1c4b3fa;p=babeltrace.git diff --git a/formats/ctf/ir/stream-class.c b/formats/ctf/ir/stream-class.c index 573fb421..b5e7e79d 100644 --- a/formats/ctf/ir/stream-class.c +++ b/formats/ctf/ir/stream-class.c @@ -34,12 +34,13 @@ #include #include #include -#include +#include #include #include #include #include #include +#include static void bt_ctf_stream_class_destroy(struct bt_object *obj); @@ -64,7 +65,7 @@ struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name) stream_class->name = g_string_new(name); stream_class->event_classes = g_ptr_array_new_with_free_func( - (GDestroyNotify) bt_put); + (GDestroyNotify) bt_object_release); if (!stream_class->event_classes) { goto error; } @@ -90,18 +91,8 @@ error: struct bt_ctf_trace *bt_ctf_stream_class_get_trace( struct bt_ctf_stream_class *stream_class) { - struct bt_ctf_trace *trace = NULL; - - if (!stream_class) { - goto end; - } - - trace = stream_class->trace; - if (trace) { - bt_get(trace); - } -end: - return trace; + return (struct bt_ctf_trace *) bt_object_get_parent( + stream_class); } const char *bt_ctf_stream_class_get_name( @@ -325,6 +316,17 @@ int bt_ctf_stream_class_add_event_class( { int ret = 0; int64_t event_id; + struct bt_ctf_trace *trace = NULL; + struct bt_ctf_stream_class *old_stream_class = NULL; + struct bt_ctf_validation_output validation_output = { 0 }; + struct bt_ctf_field_type *packet_header_type = NULL; + struct bt_ctf_field_type *packet_context_type = NULL; + struct bt_ctf_field_type *event_header_type = NULL; + struct bt_ctf_field_type *stream_event_ctx_type = NULL; + struct bt_ctf_field_type *event_context_type = NULL; + struct bt_ctf_field_type *event_payload_type = NULL; + const enum bt_ctf_validation_flag validation_flags = + BT_CTF_VALIDATION_FLAG_EVENT; if (!stream_class || !event_class) { ret = -1; @@ -340,21 +342,72 @@ int bt_ctf_stream_class_add_event_class( goto end; } - /* - * Resolve the event's sequence length and variant tags if the - * stream is already associated with a trace. Otherwise, this - * validation will be performed once the stream is registered - * to a trace. - */ - if (stream_class->trace) { - ret = bt_ctf_event_class_resolve_types(event_class, - stream_class->trace, stream_class); + old_stream_class = bt_ctf_event_class_get_stream_class(event_class); + if (old_stream_class) { + /* Event class is already associated to a stream class. */ + ret = -1; + goto end; + } + + trace = bt_ctf_stream_class_get_trace(stream_class); + if (trace) { + /* + * If the stream class is associated with a trace, then + * both those objects are frozen. Also, this event class + * is about to be frozen. + * + * Therefore the event class must be validated here. + * The trace and stream class should be valid at this + * point. + */ + assert(trace->valid); + assert(stream_class->valid); + packet_header_type = + bt_ctf_trace_get_packet_header_type(trace); + packet_context_type = + bt_ctf_stream_class_get_packet_context_type( + stream_class); + event_header_type = + bt_ctf_stream_class_get_event_header_type(stream_class); + stream_event_ctx_type = + bt_ctf_stream_class_get_event_context_type( + stream_class); + event_context_type = + bt_ctf_event_class_get_context_type(event_class); + event_payload_type = + bt_ctf_event_class_get_payload_type(event_class); + ret = bt_ctf_validate_class_types( + trace->environment, packet_header_type, + packet_context_type, event_header_type, + stream_event_ctx_type, event_context_type, + event_payload_type, trace->valid, + stream_class->valid, event_class->valid, + &validation_output, validation_flags); + BT_PUT(packet_header_type); + BT_PUT(packet_context_type); + BT_PUT(event_header_type); + BT_PUT(stream_event_ctx_type); + BT_PUT(event_context_type); + BT_PUT(event_payload_type); + if (ret) { + /* + * This means something went wrong during the + * validation process, not that the objects are + * invalid. + */ + goto end; + } + + if ((validation_output.valid_flags & validation_flags) != + validation_flags) { + /* Invalid event class */ + ret = -1; goto end; } } - /* Only set an event id if none was explicitly set before */ + /* Only set an event ID if none was explicitly set before */ event_id = bt_ctf_event_class_get_id(event_class); if (event_id < 0) { if (bt_ctf_event_class_set_id(event_class, @@ -364,18 +417,35 @@ int bt_ctf_stream_class_add_event_class( } } - ret = bt_ctf_event_class_set_stream_class(event_class, stream_class); + ret = bt_ctf_event_class_set_stream_id(event_class, stream_class->id); if (ret) { goto end; } - ret = bt_ctf_event_class_set_stream_id(event_class, stream_class->id); - if (ret) { - goto end; + bt_object_set_parent(event_class, stream_class); + + if (trace) { + /* + * At this point we know that the function will be + * successful. Therefore we can replace the event + * class's field types with what's in the validation + * output structure and mark this event class as valid. + */ + bt_ctf_validation_replace_types(NULL, NULL, event_class, + &validation_output, validation_flags); + event_class->valid = 1; + + /* + * Put what was not moved in + * bt_ctf_validation_replace_types(). + */ + bt_ctf_validation_output_put_types(&validation_output); } - bt_get(event_class); + /* Add to the event classes of the stream class */ g_ptr_array_add(stream_class->event_classes, event_class); + + /* Freeze the event class */ bt_ctf_event_class_freeze(event_class); if (stream_class->byte_order) { @@ -384,12 +454,23 @@ int bt_ctf_stream_class_add_event_class( * when the stream class was added to a trace. * * If not set here, this will be set when the stream - * classe will be added to a trace. + * class is added to a trace. */ bt_ctf_event_class_set_native_byte_order(event_class, stream_class->byte_order); } + end: + BT_PUT(trace); + BT_PUT(old_stream_class); + bt_ctf_validation_output_put_types(&validation_output); + assert(!packet_header_type); + assert(!packet_context_type); + assert(!event_header_type); + assert(!stream_event_ctx_type); + assert(!event_context_type); + assert(!event_payload_type); + return ret; } @@ -630,52 +711,31 @@ void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class) } BT_HIDDEN -int bt_ctf_stream_class_set_byte_order(struct bt_ctf_stream_class *stream_class, - enum bt_ctf_byte_order byte_order) +void bt_ctf_stream_class_set_byte_order( + struct bt_ctf_stream_class *stream_class, int byte_order) { - int i, ret = 0; - int internal_byte_order; - - /* Note that "NATIVE" means the trace's endianness, not the host's. */ - if (!stream_class || byte_order <= BT_CTF_BYTE_ORDER_UNKNOWN || - byte_order > BT_CTF_BYTE_ORDER_NETWORK) { - ret = -1; - goto end; - } - - switch (byte_order) { - case BT_CTF_BYTE_ORDER_NETWORK: - case BT_CTF_BYTE_ORDER_BIG_ENDIAN: - internal_byte_order = BIG_ENDIAN; - break; - case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN: - internal_byte_order = LITTLE_ENDIAN; - break; - default: - ret = -1; - goto end; - } + int i; - stream_class->byte_order = internal_byte_order; + assert(stream_class); + assert(byte_order == LITTLE_ENDIAN || byte_order == BIG_ENDIAN); + stream_class->byte_order = byte_order; /* Set native byte order to little or big endian */ bt_ctf_field_type_set_native_byte_order( - stream_class->event_header_type, stream_class->byte_order); + stream_class->event_header_type, byte_order); bt_ctf_field_type_set_native_byte_order( - stream_class->packet_context_type, stream_class->byte_order); + stream_class->packet_context_type, byte_order); bt_ctf_field_type_set_native_byte_order( - stream_class->event_context_type, stream_class->byte_order); + stream_class->event_context_type, byte_order); /* Set all events' native byte order */ for (i = 0; i < stream_class->event_classes->len; i++) { - bt_ctf_event_class_set_native_byte_order( - g_ptr_array_index(stream_class->event_classes, i), - stream_class->byte_order); - bt_ctf_event_class_freeze( - g_ptr_array_index(stream_class->event_classes, i)); + struct bt_ctf_event_class *event_class = + g_ptr_array_index(stream_class->event_classes, i); + + bt_ctf_event_class_set_native_byte_order(event_class, + byte_order); } -end: - return ret; } BT_HIDDEN @@ -732,28 +792,6 @@ end: return ret; } -BT_HIDDEN -int bt_ctf_stream_class_set_trace(struct bt_ctf_stream_class *stream_class, - struct bt_ctf_trace *trace) -{ - int ret = 0; - - if (!stream_class) { - ret = -1; - goto end; - } - - if (stream_class->trace && trace) { - /* Already attached to a trace */ - ret = -1; - goto end; - } - - stream_class->trace = trace; -end: - return ret; -} - static void bt_ctf_stream_class_destroy(struct bt_object *obj) { @@ -763,17 +801,6 @@ void bt_ctf_stream_class_destroy(struct bt_object *obj) bt_put(stream_class->clock); if (stream_class->event_classes) { - size_t i; - - /* Unregister this stream class from the event classes */ - for (i = 0; i < stream_class->event_classes->len; i++) { - struct bt_ctf_event_class *event_class = - g_ptr_array_index(stream_class->event_classes, - i); - - bt_ctf_event_class_set_stream_class(event_class, NULL); - } - g_ptr_array_free(stream_class->event_classes, TRUE); }