X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=b3081de487749d101906d92e33438720b305f14e;hb=44ac03eb95878883405e6cfd4e35e14ea55712f3;hp=047fc2925e19e3e79af185389f9b9fa22833125a;hpb=a4031f6749758977b2934b13fc1fb53a48ab2dfe;p=babeltrace.git diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c index 047fc292..b3081de4 100644 --- a/formats/ctf/ir/stream.c +++ b/formats/ctf/ir/stream.c @@ -30,18 +30,21 @@ #include #include #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 +70,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 +93,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 +102,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 +121,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 +138,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 +153,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 +194,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 +210,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; } @@ -247,115 +239,176 @@ end: } static -void put_event(struct bt_ctf_event *event) +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); + } +} + +static +int create_stream_file(struct bt_ctf_writer *writer, + struct bt_ctf_stream *stream) +{ + int fd; + GString *filename = g_string_new(stream->stream_class->name->str); + + if (stream->stream_class->name->len == 0) { + int64_t ret; + + ret = bt_ctf_stream_class_get_id(stream->stream_class); + if (ret < 0) { + fd = -1; + goto error; + } + + g_string_printf(filename, "stream_%" PRId64, ret); + } + + g_string_append_printf(filename, "_%" PRIu32, stream->id); + fd = openat(writer->trace_dir_fd, filename->str, + O_RDWR | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); +error: + g_string_free(filename, TRUE); + return fd; +} + +static +int set_stream_fd(struct bt_ctf_stream *stream, int fd) { - bt_ctf_event_set_stream(event, NULL); - bt_ctf_event_put(event); + int ret = 0; + + if (stream->pos.fd != -1) { + ret = -1; + goto end; + } + + ctf_init_pos(&stream->pos, NULL, fd, O_RDWR); + stream->pos.fd = fd; +end: + return ret; } -BT_HIDDEN struct bt_ctf_stream *bt_ctf_stream_create( - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_trace *trace) + struct bt_ctf_stream_class *stream_class) { int ret; struct bt_ctf_stream *stream = NULL; + struct bt_ctf_trace *trace = NULL; + struct bt_ctf_writer *writer = NULL; - if (!stream_class || !trace) { + if (!stream_class) { goto end; } - stream = g_new0(struct bt_ctf_stream, 1); - if (!stream) { + trace = bt_ctf_stream_class_get_trace(stream_class); + if (!trace) { goto end; } - /* A stream has no ownership of its trace (weak ptr) */ - stream->trace = trace; - bt_ctf_ref_init(&stream->ref_count); - stream->packet_context = bt_ctf_field_create( - stream_class->packet_context_type); - if (!stream->packet_context) { - goto error_destroy; + stream = g_new0(struct bt_ctf_stream, 1); + if (!stream) { + goto end; } + bt_object_init(stream, bt_ctf_stream_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). + * Acquire reference to parent since stream will become publicly + * reachable; it needs its parent to remain valid. */ - if (stream_class->event_context_type) { - stream->event_context = bt_ctf_field_create( - stream_class->event_context_type); + bt_object_set_parent(stream, trace); + stream->id = stream_class->next_stream_id++; + stream->stream_class = stream_class; + stream->pos.fd = -1; + + if (trace->is_created_by_writer) { + int fd; + writer = (struct bt_ctf_writer *) + bt_object_get_parent(trace); + + assert(writer); + stream->packet_context = bt_ctf_field_create( + stream_class->packet_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; - } + /* Initialize events_discarded */ + ret = set_structure_field_integer(stream->packet_context, + "events_discarded", 0); + if (ret) { + 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) put_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; + stream->events = g_ptr_array_new_with_free_func( + (GDestroyNotify) release_event); + if (!stream->events) { + 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; - } - /* - * Attempt to populate the default trace packet header fields - * (magic, uuid and stream_id). This will _not_ fail shall the - * fields not be found or be of an incompatible type; they will - * simply not be populated automatically. The user will have to - * make sure to set the trace packet header fields himself before - * flushing. - */ - ret = set_packet_header(stream); - if (ret) { - goto error_destroy; - } -end: - return stream; -error_destroy: - bt_ctf_stream_destroy(&stream->ref_count); - return NULL; -} + /* 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; + } -BT_HIDDEN -int bt_ctf_stream_set_fd(struct bt_ctf_stream *stream, int fd) -{ - int ret = 0; + /* + * Attempt to populate the default trace packet header fields + * (magic, uuid and stream_id). This will _not_ fail shall the + * fields not be found or be of an incompatible type; they will + * simply not be populated automatically. The user will have to + * make sure to set the trace packet header fields himself + * before flushing. + */ + ret = set_packet_header(stream); + if (ret) { + goto error; + } - if (stream->pos.fd != -1) { - ret = -1; - goto end; + /* Create file associated with this stream */ + fd = create_stream_file(writer, stream); + if (fd < 0) { + goto error; + } + + ret = set_stream_fd(stream, fd); + if (ret) { + goto error; + } + + /* Freeze the writer */ + bt_ctf_writer_freeze(writer); + } else { + /* Non-writer stream indicated by a negative FD */ + ret = set_stream_fd(stream, -1); + if (ret) { + goto error; + } } - ctf_init_pos(&stream->pos, NULL, fd, O_RDWR); - stream->pos.fd = fd; + /* Add this stream to the trace's streams */ + g_ptr_array_add(trace->streams, stream); + end: - return ret; + BT_PUT(trace); + BT_PUT(writer); + return stream; +error: + BT_PUT(stream); + BT_PUT(trace); + BT_PUT(writer); + return stream; } struct bt_ctf_stream_class *bt_ctf_stream_get_class( @@ -368,7 +421,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; } @@ -381,7 +434,8 @@ int bt_ctf_stream_get_discarded_events_count( struct bt_ctf_field *events_discarded_field = NULL; struct bt_ctf_field_type *events_discarded_field_type = NULL; - if (!stream || !count || !stream->packet_context) { + if (!stream || !count || !stream->packet_context || + stream->pos.fd < 0) { ret = -1; goto end; } @@ -429,12 +483,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; } @@ -448,7 +498,7 @@ void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, struct bt_ctf_field *events_discarded_field = NULL; struct bt_ctf_field_type *events_discarded_field_type = NULL; - if (!stream || !stream->packet_context) { + if (!stream || !stream->packet_context || stream->pos.fd < 0) { goto end; } @@ -492,67 +542,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; - } - - ret = bt_ctf_event_set_stream(event, stream); - if (ret) { - /* Event was already associated to a stream */ + if (!stream || !event || stream->pos.fd < 0) { 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 and freeze it */ + bt_ctf_event_freeze(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; } @@ -562,13 +595,13 @@ struct bt_ctf_field *bt_ctf_stream_get_packet_context( { struct bt_ctf_field *packet_context = NULL; - if (!stream) { + if (!stream || stream->pos.fd < 0) { goto end; } packet_context = stream->packet_context; if (packet_context) { - bt_ctf_field_get(packet_context); + bt_get(packet_context); } end: return packet_context; @@ -580,81 +613,38 @@ int bt_ctf_stream_set_packet_context(struct bt_ctf_stream *stream, int ret = 0; struct bt_ctf_field_type *field_type; - if (!stream || !field) { + if (!stream || !field || stream->pos.fd < 0) { ret = -1; goto end; } 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) { struct bt_ctf_field *packet_header = NULL; - if (!stream) { + if (!stream || stream->pos.fd < 0) { goto end; } packet_header = stream->packet_header; if (packet_header) { - bt_ctf_field_get(packet_header); + bt_get(packet_header); } end: return packet_header; @@ -664,26 +654,27 @@ 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) { + if (!stream || !field || stream->pos.fd < 0) { ret = -1; 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; } @@ -704,7 +695,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; } @@ -726,8 +717,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; } @@ -844,10 +835,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; } @@ -886,66 +876,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 (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); } @@ -977,7 +940,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 @@ -994,11 +957,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; }