X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=cc5548b548033345239bd1e4c0234e2c116f3460;hb=09840de5d022697671dafe2bed427fa5c09b40b9;hp=6a71466ca3a60022a178b684b43508e4bed6a5be;hpb=29d9d76c476cbf3fdf6fa709bfbdc24309974f06;p=babeltrace.git diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c index 6a71466c..cc5548b5 100644 --- a/formats/ctf/ir/stream.c +++ b/formats/ctf/ir/stream.c @@ -35,13 +35,14 @@ #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); @@ -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( @@ -143,6 +141,7 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream) 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 @@ -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,12 +269,16 @@ 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; + goto error; } /* @@ -280,8 +290,8 @@ struct bt_ctf_stream *bt_ctf_stream_create( 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; + if (!stream->event_context) { + goto error; } } @@ -289,29 +299,31 @@ struct bt_ctf_stream *bt_ctf_stream_create( 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; + goto error; } if (stream_class->event_context_type) { stream->event_contexts = g_ptr_array_new_with_free_func( - (GDestroyNotify) bt_ctf_field_put); + (GDestroyNotify) bt_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; + } /* * Attempt to populate the default trace packet header fields * (magic, uuid and stream_id). This will _not_ fail shall the @@ -322,13 +334,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 @@ -347,13 +360,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) { @@ -364,7 +370,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; } @@ -425,12 +431,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; } @@ -488,19 +490,14 @@ 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; - uint64_t timestamp; struct bt_ctf_field *event_context_copy = NULL; if (!stream || !event) { @@ -508,6 +505,12 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, 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 */ ret = bt_ctf_event_validate(event); if (ret) { @@ -529,19 +532,26 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, } } - timestamp = bt_ctf_clock_get_time(stream->stream_class->clock); - ret = bt_ctf_event_set_timestamp(event, timestamp); - if (ret) { - goto end; - } - - bt_ctf_event_get(event); /* Save the new event along with its associated stream event context */ 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; } @@ -556,7 +566,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; @@ -574,14 +584,15 @@ 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; @@ -598,7 +609,7 @@ struct bt_ctf_field *bt_ctf_stream_get_event_context( event_context = stream->event_context; if (event_context) { - bt_ctf_field_get(event_context); + bt_get(event_context); } end: return event_context; @@ -616,18 +627,17 @@ int bt_ctf_stream_set_event_context(struct bt_ctf_stream *stream, } field_type = bt_ctf_field_get_type(field); - if (field_type != stream->stream_class->event_context_type) { + if (bt_ctf_field_type_compare(field_type, + stream->stream_class->event_context_type)) { ret = -1; goto end; } - bt_ctf_field_get(field); - bt_ctf_field_put(stream->event_context); + bt_get(field); + bt_put(stream->event_context); stream->event_context = field; end: - if (field_type) { - bt_ctf_field_type_put(field_type); - } + bt_put(field_type); return ret; } @@ -642,7 +652,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; @@ -652,6 +662,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) { @@ -659,19 +670,63 @@ 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; +} + +static +int get_event_header_timestamp(struct bt_ctf_field *event_header, uint64_t *timestamp) +{ + int ret = 0; + struct bt_ctf_field *timestamp_field = NULL; + struct bt_ctf_field_type *timestamp_field_type = NULL; + + timestamp_field = bt_ctf_field_structure_get_field(event_header, + "timestamp"); + if (!timestamp_field) { + ret = -1; + goto end; + } + + 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) { + ret = -1; + goto end; + } + + if (bt_ctf_field_type_integer_get_signed(timestamp_field_type)) { + int64_t val; + + ret = bt_ctf_field_signed_integer_get_value(timestamp_field, + &val); + if (ret) { + goto end; + } + *timestamp = (uint64_t) val; + } else { + ret = bt_ctf_field_unsigned_integer_get_value(timestamp_field, + timestamp); + if (ret) { + goto end; + } } +end: + bt_put(timestamp_field); + bt_put(timestamp_field_type); return ret; } @@ -680,7 +735,6 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) int ret = 0; size_t i; uint64_t timestamp_begin, timestamp_end, events_discarded; - struct bt_ctf_stream_class *stream_class; struct bt_ctf_field *integer = NULL; struct ctf_stream_pos packet_context_pos; @@ -702,35 +756,36 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) goto end; } - if (stream->flushed_packet_count) { - /* ctf_init_pos has already initialized the first packet */ - ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR); - } + /* mmap the next packet */ + ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR); ret = bt_ctf_field_serialize(stream->packet_header, &stream->pos); if (ret) { goto end; } - stream_class = stream->stream_class; - timestamp_begin = ((struct bt_ctf_event *) g_ptr_array_index( - stream->events, 0))->timestamp; - timestamp_end = ((struct bt_ctf_event *) g_ptr_array_index( - stream->events, stream->events->len - 1))->timestamp; - /* Set the default context attributes if present and unset. */ - ret = set_structure_field_integer(stream->packet_context, - "timestamp_begin", timestamp_begin); - if (ret) { - goto end; + if (!get_event_header_timestamp( + ((struct bt_ctf_event *) g_ptr_array_index( + stream->events, 0))->event_header, ×tamp_begin)) { + ret = set_structure_field_integer(stream->packet_context, + "timestamp_begin", timestamp_begin); + if (ret) { + goto end; + } } - ret = set_structure_field_integer(stream->packet_context, - "timestamp_end", timestamp_end); - if (ret) { - goto end; - } + if (!get_event_header_timestamp( + ((struct bt_ctf_event *) g_ptr_array_index( + stream->events, stream->events->len - 1))->event_header, + ×tamp_end)) { + ret = set_structure_field_integer(stream->packet_context, + "timestamp_end", timestamp_end); + if (ret) { + goto end; + } + } ret = set_structure_field_integer(stream->packet_context, "content_size", UINT64_MAX); if (ret) { @@ -774,28 +829,14 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) for (i = 0; i < stream->events->len; i++) { struct bt_ctf_event *event = g_ptr_array_index( stream->events, i); - uint32_t event_id = bt_ctf_event_class_get_id( - event->event_class); - uint64_t timestamp = bt_ctf_event_get_timestamp(event); - ret = bt_ctf_field_reset(stream_class->event_header); - if (ret) { - goto end; - } - - ret = set_structure_field_integer(stream_class->event_header, - "id", event_id); - if (ret) { - goto end; - } - ret = set_structure_field_integer(stream_class->event_header, - "timestamp", timestamp); + ret = bt_ctf_field_reset(event->event_header); if (ret) { goto end; } /* Write event header */ - ret = bt_ctf_field_serialize(stream_class->event_header, + ret = bt_ctf_field_serialize(event->event_header, &stream->pos); if (ret) { goto end; @@ -849,61 +890,40 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) } 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); } @@ -952,11 +972,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; }