X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=517a11e63e00d89fffb76f11cb76f53e32dca948;hb=5fd2e9fda6185e989583e6e61b9312683149747e;hp=6a6a3a77f57580bc2069a3b96f7d57fdba18520d;hpb=83509119a945fc77faff869daaf48627e1c4b3fa;p=babeltrace.git diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c index 6a6a3a77..517a11e6 100644 --- a/formats/ctf/ir/stream.c +++ b/formats/ctf/ir/stream.c @@ -30,8 +30,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -68,7 +68,7 @@ int set_packet_header_magic(struct bt_ctf_stream *stream) assert(magic_field_type); if (bt_ctf_field_type_get_type_id(magic_field_type) != - CTF_TYPE_INTEGER) { + BT_CTF_TYPE_ID_INTEGER) { /* Magic field is not an integer. Not an error, skip. */ goto end; } @@ -100,6 +100,7 @@ static int set_packet_header_uuid(struct bt_ctf_stream *stream) { int i, ret = 0; + struct bt_ctf_trace *trace = NULL; struct bt_ctf_field_type *uuid_field_type = NULL; struct bt_ctf_field_type *element_field_type = NULL; struct bt_ctf_field *uuid_field = bt_ctf_field_structure_get_field( @@ -118,7 +119,7 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream) uuid_field_type = bt_ctf_field_get_type(uuid_field); assert(uuid_field_type); if (bt_ctf_field_type_get_type_id(uuid_field_type) != - CTF_TYPE_ARRAY) { + BT_CTF_TYPE_ID_ARRAY) { /* UUID field is not an array. Not an error, skip. */ goto end; } @@ -135,11 +136,12 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream) uuid_field_type); assert(element_field_type); if (bt_ctf_field_type_get_type_id(element_field_type) != - CTF_TYPE_INTEGER) { + BT_CTF_TYPE_ID_INTEGER) { /* UUID array elements are not integers. Not an error, skip */ goto end; } + trace = (struct bt_ctf_trace *) bt_object_get_parent(stream); for (i = 0; i < 16; i++) { struct bt_ctf_field *uuid_element = bt_ctf_field_array_get_field(uuid_field, i); @@ -149,11 +151,11 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream) if (ret) { ret = bt_ctf_field_signed_integer_set_value( - uuid_element, (int64_t) stream->trace->uuid[i]); + uuid_element, (int64_t) trace->uuid[i]); } else { ret = bt_ctf_field_unsigned_integer_set_value( uuid_element, - (uint64_t) stream->trace->uuid[i]); + (uint64_t) trace->uuid[i]); } bt_put(uuid_element); if (ret) { @@ -165,6 +167,7 @@ end: bt_put(uuid_field); bt_put(uuid_field_type); bt_put(element_field_type); + BT_PUT(trace); return ret; } static @@ -189,7 +192,7 @@ int set_packet_header_stream_id(struct bt_ctf_stream *stream) stream_id_field_type = bt_ctf_field_get_type(stream_id_field); assert(stream_id_field_type); if (bt_ctf_field_type_get_type_id(stream_id_field_type) != - CTF_TYPE_INTEGER) { + BT_CTF_TYPE_ID_INTEGER) { /* stream_id field is not an integer. Not an error, skip. */ goto end; } @@ -234,10 +237,19 @@ end: } static -void put_event(struct bt_ctf_event *event) +void release_event(struct bt_ctf_event *event) { - bt_ctf_event_set_stream(event, NULL); - bt_put(event); + if (bt_object_get_ref_count(event)) { + /* + * The event is being orphaned, but it must guarantee the + * existence of its event class for the duration of its + * lifetime. + */ + bt_get(event->event_class); + BT_PUT(event->base.parent); + } else { + bt_object_release(event); + } } BT_HIDDEN @@ -257,29 +269,18 @@ struct bt_ctf_stream *bt_ctf_stream_create( goto end; } - /* A stream has no ownership of its trace (weak ptr) */ - stream->trace = trace; bt_object_init(stream, bt_ctf_stream_destroy); + /* + * Acquire reference to parent since stream will become publicly + * reachable; it needs its parent to remain valid. + */ + bt_object_set_parent(stream, trace); stream->packet_context = bt_ctf_field_create( stream_class->packet_context_type); if (!stream->packet_context) { goto error; } - /* - * A stream class may not have a stream event context defined - * in which case this stream will never have a stream_event_context - * member since, after a stream's creation, the parent stream class - * is "frozen" (immutable). - */ - if (stream_class->event_context_type) { - stream->event_context = bt_ctf_field_create( - stream_class->event_context_type); - if (!stream->packet_context) { - goto error; - } - } - /* Initialize events_discarded */ ret = set_structure_field_integer(stream->packet_context, "events_discarded", 0); @@ -290,19 +291,11 @@ struct bt_ctf_stream *bt_ctf_stream_create( stream->pos.fd = -1; stream->id = stream_class->next_stream_id++; stream->stream_class = stream_class; - bt_get(stream_class); stream->events = g_ptr_array_new_with_free_func( - (GDestroyNotify) put_event); + (GDestroyNotify) release_event); if (!stream->events) { goto error; } - if (stream_class->event_context_type) { - stream->event_contexts = g_ptr_array_new_with_free_func( - (GDestroyNotify) bt_ctf_field_put); - if (!stream->event_contexts) { - goto error; - } - } /* A trace is not allowed to have a NULL packet header */ assert(trace->packet_header_type); @@ -326,6 +319,7 @@ end: return stream; error: BT_PUT(stream); + bt_put(trace); return stream; } @@ -483,55 +477,41 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event) { int ret = 0; - struct bt_ctf_field *event_context_copy = NULL; if (!stream || !event) { ret = -1; goto end; } - ret = bt_ctf_event_set_stream(event, stream); - if (ret) { - /* Event was already associated to a stream */ - ret = -1; - goto end; - } - + bt_object_set_parent(event, stream); ret = bt_ctf_event_populate_event_header(event); if (ret) { goto end; } - /* Make sure the event's payload is set */ + /* Make sure the various scopes of the event are set */ ret = bt_ctf_event_validate(event); if (ret) { goto end; } - /* Sample the current stream event context by copying it */ - if (stream->event_context) { - /* Make sure the event context's payload is set */ - ret = bt_ctf_field_validate(stream->event_context); - if (ret) { - goto end; - } - - event_context_copy = bt_ctf_field_copy(stream->event_context); - if (!event_context_copy) { - ret = -1; - goto end; - } - } - - bt_get(event); - /* Save the new event along with its associated stream event context */ + /* Save the new event */ g_ptr_array_add(stream->events, event); - if (event_context_copy) { - g_ptr_array_add(stream->event_contexts, event_context_copy); - } + + /* + * Event had to hold a reference to its event class as long as it wasn't + * part of the same trace hierarchy. From now on, the event and its + * class share the same lifetime guarantees and the reference is no + * longer needed. + */ + bt_put(event->event_class); end: if (ret) { - (void) bt_ctf_event_set_stream(event, NULL); + /* + * Orphan the event; we were not succesful in associating it to + * a stream. + */ + bt_object_set_parent(event, NULL); } return ret; } @@ -565,7 +545,8 @@ int bt_ctf_stream_set_packet_context(struct bt_ctf_stream *stream, } field_type = bt_ctf_field_get_type(field); - if (field_type != stream->stream_class->packet_context_type) { + if (bt_ctf_field_type_compare(field_type, + stream->stream_class->packet_context_type)) { ret = -1; goto end; } @@ -578,48 +559,6 @@ end: return ret; } -struct bt_ctf_field *bt_ctf_stream_get_event_context( - struct bt_ctf_stream *stream) -{ - struct bt_ctf_field *event_context = NULL; - - if (!stream) { - goto end; - } - - event_context = stream->event_context; - if (event_context) { - bt_get(event_context); - } -end: - return event_context; -} - -int bt_ctf_stream_set_event_context(struct bt_ctf_stream *stream, - struct bt_ctf_field *field) -{ - int ret = 0; - struct bt_ctf_field_type *field_type = NULL; - - if (!stream || !field) { - ret = -1; - goto end; - } - - field_type = bt_ctf_field_get_type(field); - if (field_type != stream->stream_class->event_context_type) { - ret = -1; - goto end; - } - - bt_get(field); - bt_put(stream->event_context); - stream->event_context = field; -end: - bt_put(field_type); - return ret; -} - struct bt_ctf_field *bt_ctf_stream_get_packet_header( struct bt_ctf_stream *stream) { @@ -641,6 +580,7 @@ int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream, struct bt_ctf_field *field) { int ret = 0; + struct bt_ctf_trace *trace = NULL; struct bt_ctf_field_type *field_type = NULL; if (!stream || !field) { @@ -648,8 +588,9 @@ int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream, goto end; } + trace = (struct bt_ctf_trace *) bt_object_get_parent(stream); field_type = bt_ctf_field_get_type(field); - if (field_type != stream->trace->packet_header_type) { + if (bt_ctf_field_type_compare(field_type, trace->packet_header_type)) { ret = -1; goto end; } @@ -658,6 +599,7 @@ int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream, bt_put(stream->packet_header); stream->packet_header = field; end: + BT_PUT(trace); bt_put(field_type); return ret; } @@ -679,7 +621,7 @@ int get_event_header_timestamp(struct bt_ctf_field *event_header, uint64_t *time timestamp_field_type = bt_ctf_field_get_type(timestamp_field); assert(timestamp_field_type); if (bt_ctf_field_type_get_type_id(timestamp_field_type) != - CTF_TYPE_INTEGER) { + BT_CTF_TYPE_ID_INTEGER) { ret = -1; goto end; } @@ -819,10 +761,9 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) } /* Write stream event context */ - if (stream->event_contexts) { + if (event->stream_event_context) { ret = bt_ctf_field_serialize( - g_ptr_array_index(stream->event_contexts, i), - &stream->pos); + event->stream_event_context, &stream->pos); if (ret) { goto end; } @@ -861,9 +802,6 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) } g_ptr_array_set_size(stream->events, 0); - if (stream->event_contexts) { - g_ptr_array_set_size(stream->event_contexts, 0); - } stream->flushed_packet_count++; end: bt_put(integer); @@ -891,13 +829,9 @@ void bt_ctf_stream_destroy(struct bt_object *obj) perror("close"); } - bt_put(stream->stream_class); if (stream->events) { g_ptr_array_free(stream->events, TRUE); } - if (stream->event_contexts) { - g_ptr_array_free(stream->event_contexts, TRUE); - } bt_put(stream->packet_header); bt_put(stream->packet_context); bt_put(stream->event_context); @@ -932,7 +866,7 @@ int set_structure_field_integer(struct bt_ctf_field *structure, char *name, field_type = bt_ctf_field_get_type(integer); /* Something is serioulsly wrong */ assert(field_type); - if (bt_ctf_field_type_get_type_id(field_type) != CTF_TYPE_INTEGER) { + if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_TYPE_ID_INTEGER) { /* * The user most likely meant for us to populate this field * automatically. However, we can only do this if the field