X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=517a11e63e00d89fffb76f11cb76f53e32dca948;hb=4ce9f9d080c7f4ef686f53e9a0a26e389fafe1fc;hp=70e2ec2a0ab0218d4190955e09a3ceb67dbb3709;hpb=9235146064cacb819bbb4edbebed1e41952eb77c;p=babeltrace.git diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c index 70e2ec2a..517a11e6 100644 --- a/formats/ctf/ir/stream.c +++ b/formats/ctf/ir/stream.c @@ -30,18 +30,19 @@ #include #include #include -#include -#include +#include +#include #include #include #include +#include #include #include #include #include static -void bt_ctf_stream_destroy(struct bt_ctf_ref *ref); +void bt_ctf_stream_destroy(struct bt_object *obj); static int set_structure_field_integer(struct bt_ctf_field *, char *, uint64_t); @@ -67,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; } @@ -90,12 +91,8 @@ int set_packet_header_magic(struct bt_ctf_stream *stream) (uint64_t) 0xC1FC1FC1); } end: - if (magic_field) { - bt_ctf_field_put(magic_field); - } - if (magic_field_type) { - bt_ctf_field_type_put(magic_field_type); - } + bt_put(magic_field); + bt_put(magic_field_type); return ret; } @@ -103,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( @@ -121,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; } @@ -138,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); @@ -152,28 +151,23 @@ 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_ctf_field_put(uuid_element); + bt_put(uuid_element); if (ret) { goto end; } } end: - if (uuid_field) { - bt_ctf_field_put(uuid_field); - } - if (uuid_field_type) { - bt_ctf_field_type_put(uuid_field_type); - } - if (element_field_type) { - bt_ctf_field_type_put(element_field_type); - } + bt_put(uuid_field); + bt_put(uuid_field_type); + bt_put(element_field_type); + BT_PUT(trace); return ret; } static @@ -198,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; } @@ -214,12 +208,8 @@ int set_packet_header_stream_id(struct bt_ctf_stream *stream) (uint64_t) stream_id); } end: - if (stream_id_field) { - bt_ctf_field_put(stream_id_field); - } - if (stream_id_field_type) { - bt_ctf_field_type_put(stream_id_field_type); - } + bt_put(stream_id_field); + bt_put(stream_id_field_type); return ret; } @@ -246,6 +236,22 @@ end: return ret; } +static +void release_event(struct bt_ctf_event *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 struct bt_ctf_stream *bt_ctf_stream_create( struct bt_ctf_stream_class *stream_class, @@ -263,57 +269,39 @@ struct bt_ctf_stream *bt_ctf_stream_create( goto end; } - stream->trace = trace; - bt_ctf_ref_init(&stream->ref_count); + 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_destroy; - } - - /* - * 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_destroy; - } + goto error; } /* Initialize events_discarded */ ret = set_structure_field_integer(stream->packet_context, "events_discarded", 0); if (ret) { - goto error_destroy; + goto error; } stream->pos.fd = -1; stream->id = stream_class->next_stream_id++; stream->stream_class = stream_class; - bt_ctf_stream_class_get(stream_class); stream->events = g_ptr_array_new_with_free_func( - (GDestroyNotify) bt_ctf_event_put); + (GDestroyNotify) release_event); if (!stream->events) { - goto error_destroy; - } - 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_destroy; - } + goto error; } /* A trace is not allowed to have a NULL packet header */ assert(trace->packet_header_type); stream->packet_header = bt_ctf_field_create(trace->packet_header_type); if (!stream->packet_header) { - goto error_destroy; + goto error; } /* * Attempt to populate the default trace packet header fields @@ -325,13 +313,14 @@ struct bt_ctf_stream *bt_ctf_stream_create( */ ret = set_packet_header(stream); if (ret) { - goto error_destroy; + goto error; } end: return stream; -error_destroy: - bt_ctf_stream_destroy(&stream->ref_count); - return NULL; +error: + BT_PUT(stream); + bt_put(trace); + return stream; } BT_HIDDEN @@ -350,13 +339,6 @@ end: return ret; } -BT_HIDDEN -void bt_ctf_stream_set_trace(struct bt_ctf_stream *stream, - struct bt_ctf_trace *trace) -{ - stream->trace = trace; -} - struct bt_ctf_stream_class *bt_ctf_stream_get_class( struct bt_ctf_stream *stream) { @@ -367,7 +349,7 @@ struct bt_ctf_stream_class *bt_ctf_stream_get_class( } stream_class = stream->stream_class; - bt_ctf_stream_class_get(stream_class); + bt_get(stream_class); end: return stream_class; } @@ -428,12 +410,8 @@ int bt_ctf_stream_get_discarded_events_count( } } end: - if (events_discarded_field) { - bt_ctf_field_put(events_discarded_field); - } - if (events_discarded_field_type) { - bt_ctf_field_type_put(events_discarded_field_type); - } + bt_put(events_discarded_field); + bt_put(events_discarded_field_type); return ret; } @@ -491,58 +469,50 @@ void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, } end: - if (events_discarded_field) { - bt_ctf_field_put(events_discarded_field); - } - if (events_discarded_field_type) { - bt_ctf_field_type_put(events_discarded_field_type); - } + bt_put(events_discarded_field); + bt_put(events_discarded_field_type); } 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; } + 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_ctf_event_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) { + /* + * Orphan the event; we were not succesful in associating it to + * a stream. + */ + bt_object_set_parent(event, NULL); + } return ret; } @@ -557,7 +527,7 @@ struct bt_ctf_field *bt_ctf_stream_get_packet_context( packet_context = stream->packet_context; if (packet_context) { - bt_ctf_field_get(packet_context); + bt_get(packet_context); } end: return packet_context; @@ -575,63 +545,20 @@ 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; } - bt_ctf_field_type_put(field_type); - bt_ctf_field_get(field); - bt_ctf_field_put(stream->packet_context); + bt_put(field_type); + bt_get(field); + bt_put(stream->packet_context); stream->packet_context = field; 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_ctf_field_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_ctf_field_get(field); - bt_ctf_field_put(stream->event_context); - stream->event_context = field; -end: - if (field_type) { - bt_ctf_field_type_put(field_type); - } - return ret; -} - struct bt_ctf_field *bt_ctf_stream_get_packet_header( struct bt_ctf_stream *stream) { @@ -643,7 +570,7 @@ struct bt_ctf_field *bt_ctf_stream_get_packet_header( packet_header = stream->packet_header; if (packet_header) { - bt_ctf_field_get(packet_header); + bt_get(packet_header); } end: return packet_header; @@ -653,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) { @@ -660,19 +588,19 @@ 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; } - bt_ctf_field_get(field); - bt_ctf_field_put(stream->packet_header); + bt_get(field); + bt_put(stream->packet_header); stream->packet_header = field; end: - if (field_type) { - bt_ctf_field_type_put(field_type); - } + BT_PUT(trace); + bt_put(field_type); return ret; } @@ -693,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; } @@ -715,8 +643,8 @@ int get_event_header_timestamp(struct bt_ctf_field *event_header, uint64_t *time } } end: - bt_ctf_field_put(timestamp_field); - bt_ctf_field_type_put(timestamp_field_type); + bt_put(timestamp_field); + bt_put(timestamp_field_type); return ret; } @@ -833,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; } @@ -875,66 +802,39 @@ 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_ctf_field_put(integer); + bt_put(integer); return ret; } void bt_ctf_stream_get(struct bt_ctf_stream *stream) { - if (!stream) { - return; - } - - bt_ctf_ref_get(&stream->ref_count); + bt_get(stream); } void bt_ctf_stream_put(struct bt_ctf_stream *stream) { - if (!stream) { - return; - } - - bt_ctf_ref_put(&stream->ref_count, bt_ctf_stream_destroy); + bt_put(stream); } static -void bt_ctf_stream_destroy(struct bt_ctf_ref *ref) +void bt_ctf_stream_destroy(struct bt_object *obj) { struct bt_ctf_stream *stream; - if (!ref) { - return; - } - - stream = container_of(ref, struct bt_ctf_stream, ref_count); + stream = container_of(obj, struct bt_ctf_stream, base); ctf_fini_pos(&stream->pos); - if (close(stream->pos.fd)) { + if (stream->pos.fd >= 0 && close(stream->pos.fd)) { perror("close"); } - if (stream->stream_class) { - bt_ctf_stream_class_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); - } - if (stream->packet_header) { - bt_ctf_field_put(stream->packet_header); - } - if (stream->packet_context) { - bt_ctf_field_put(stream->packet_context); - } - if (stream->event_context) { - bt_ctf_field_put(stream->event_context); - } + bt_put(stream->packet_header); + bt_put(stream->packet_context); + bt_put(stream->event_context); g_free(stream); } @@ -966,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 @@ -983,11 +883,7 @@ int set_structure_field_integer(struct bt_ctf_field *structure, char *name, ret = bt_ctf_field_unsigned_integer_set_value(integer, value); } end: - if (integer) { - bt_ctf_field_put(integer); - } - if (field_type) { - bt_ctf_field_type_put(field_type); - } + bt_put(integer); + bt_put(field_type); return ret; }