X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=74c6f52b5828bcf8b278486b25666cfde0e27628;hb=9643611120f9bf174684cb0a06ec9ed418e3341e;hp=717925761336bfef2ada9b1f5b2287ff3f3fdd3e;hpb=a6b2126688597b7527281567973ee3ca7312c14b;p=babeltrace.git diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c index 71792576..74c6f52b 100644 --- a/formats/ctf/ir/stream.c +++ b/formats/ctf/ir/stream.c @@ -26,15 +26,18 @@ * SOFTWARE. */ -#include -#include +#include +#include +#include #include #include -#include -#include +#include +#include #include #include #include +#include +#include #include #include #include @@ -46,6 +49,45 @@ void bt_ctf_stream_destroy(struct bt_object *obj); static int set_structure_field_integer(struct bt_ctf_field *, char *, uint64_t); +static +int set_integer_field_value(struct bt_ctf_field* field, uint64_t value) +{ + int ret = 0; + struct bt_ctf_field_type *field_type = NULL; + + if (!field) { + ret = -1; + goto end; + } + + field_type = bt_ctf_field_get_type(field); + assert(field_type); + + if (bt_ctf_field_type_get_type_id(field_type) != + BT_CTF_TYPE_ID_INTEGER) { + /* Not an integer and the value is unset, error. */ + ret = -1; + goto end; + } + + if (bt_ctf_field_type_integer_get_signed(field_type)) { + ret = bt_ctf_field_signed_integer_set_value(field, (int64_t) value); + if (ret) { + /* Value is out of range, error. */ + goto end; + } + } else { + ret = bt_ctf_field_unsigned_integer_set_value(field, value); + if (ret) { + /* Value is out of range, error. */ + goto end; + } + } +end: + bt_put(field_type); + return ret; +} + static int set_packet_header_magic(struct bt_ctf_stream *stream) { @@ -59,7 +101,7 @@ int set_packet_header_magic(struct bt_ctf_stream *stream) goto end; } - if (!bt_ctf_field_validate(magic_field)) { + if (bt_ctf_field_is_set(magic_field)) { /* Value already set. Not an error, skip. */ goto end; } @@ -68,7 +110,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; } @@ -111,7 +153,7 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream) goto end; } - if (!bt_ctf_field_validate(uuid_field)) { + if (bt_ctf_field_is_set(uuid_field)) { /* Value already set. Not an error, skip. */ goto end; } @@ -119,7 +161,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; } @@ -136,7 +178,7 @@ 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; } @@ -184,7 +226,7 @@ int set_packet_header_stream_id(struct bt_ctf_stream *stream) goto end; } - if (!bt_ctf_field_validate(stream_id_field)) { + if (bt_ctf_field_is_set(stream_id_field)) { /* Value already set. Not an error, skip. */ goto end; } @@ -192,7 +234,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; } @@ -252,21 +294,71 @@ void release_event(struct bt_ctf_event *event) } } -BT_HIDDEN +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) +{ + 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; +} + 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, + const char *name) { int ret; struct bt_ctf_stream *stream = NULL; + struct bt_ctf_trace *trace = NULL; + struct bt_ctf_writer *writer = NULL; - if (!stream_class || !trace) { - goto end; + if (!stream_class) { + goto error; + } + + trace = bt_ctf_stream_class_get_trace(stream_class); + if (!trace) { + goto error; } stream = g_new0(struct bt_ctf_stream, 1); if (!stream) { - goto end; + goto error; } bt_object_init(stream, bt_ctf_stream_destroy); @@ -275,91 +367,97 @@ struct bt_ctf_stream *bt_ctf_stream_create( * 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; - } + stream->id = stream_class->next_stream_id++; + stream->stream_class = stream_class; + stream->pos.fd = -1; - /* - * 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->event_context) { + if (name) { + stream->name = g_string_new(name); + if (!stream->name) { goto error; } } - /* Initialize events_discarded */ - ret = set_structure_field_integer(stream->packet_context, - "events_discarded", 0); - if (ret) { - goto error; - } + if (trace->is_created_by_writer) { + int fd; + writer = (struct bt_ctf_writer *) + bt_object_get_parent(trace); - stream->pos.fd = -1; - stream->id = stream_class->next_stream_id++; - stream->stream_class = stream_class; - stream->events = g_ptr_array_new_with_free_func( - (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_put); - if (!stream->event_contexts) { + assert(writer); + stream->packet_context = bt_ctf_field_create( + stream_class->packet_context_type); + if (!stream->packet_context) { 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 - * 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; + /* Initialize events_discarded */ + ret = set_structure_field_integer(stream->packet_context, + "events_discarded", 0); + if (ret) { + goto error; + } + + 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; + } + + /* + * 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; + } + + /* 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; + } } -end: + + /* Add this stream to the trace's streams */ + g_ptr_array_add(trace->streams, stream); + + BT_PUT(trace); + BT_PUT(writer); return stream; error: BT_PUT(stream); - bt_put(trace); + BT_PUT(trace); + BT_PUT(writer); return stream; } -BT_HIDDEN -int bt_ctf_stream_set_fd(struct bt_ctf_stream *stream, int fd) -{ - 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; -} - struct bt_ctf_stream_class *bt_ctf_stream_get_class( struct bt_ctf_stream *stream) { @@ -383,7 +481,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; } @@ -446,7 +545,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; } @@ -494,49 +593,125 @@ end: bt_put(events_discarded_field_type); } -int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, +static int auto_populate_event_header(struct bt_ctf_stream *stream, struct bt_ctf_event *event) { int ret = 0; - struct bt_ctf_field *event_context_copy = NULL; + struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL; + struct bt_ctf_clock_class *mapped_clock_class = NULL; - if (!stream || !event) { + if (!event || event->frozen) { ret = -1; goto end; } - bt_object_set_parent(event, stream); - ret = bt_ctf_event_populate_event_header(event); - if (ret) { + /* + * The condition to automatically set the ID are: + * + * 1. The event header field "id" exists and is an integer + * field. + * 2. The event header field "id" is NOT set. + */ + id_field = bt_ctf_field_structure_get_field(event->event_header, "id"); + if (id_field && !bt_ctf_field_is_set(id_field)) { + ret = set_integer_field_value(id_field, + (uint64_t) bt_ctf_event_class_get_id( + event->event_class)); + if (ret) { + goto end; + } + } + + /* + * The conditions to automatically set the timestamp are: + * + * 1. The event header field "timestamp" exists and is an + * integer field. + * 2. This stream's class has a registered clock (set with + * bt_ctf_stream_class_set_clock()). + * 3. The event header field "timestamp" has its type mapped to + * a clock class which is also the clock class of this + * stream's class's registered clock. + * 4. The event header field "timestamp" is NOT set. + */ + timestamp_field = bt_ctf_field_structure_get_field(event->event_header, + "timestamp"); + if (timestamp_field && !bt_ctf_field_is_set(timestamp_field) && + stream->stream_class->clock) { + struct bt_ctf_clock_class *stream_class_clock_class = + stream->stream_class->clock->clock_class; + struct bt_ctf_field_type *timestamp_field_type = + bt_ctf_field_get_type(timestamp_field); + + assert(timestamp_field_type); + mapped_clock_class = + bt_ctf_field_type_integer_get_mapped_clock_class( + timestamp_field_type); + BT_PUT(timestamp_field_type); + if (mapped_clock_class == stream_class_clock_class) { + uint64_t timestamp; + + ret = bt_ctf_clock_get_value( + stream->stream_class->clock, + ×tamp); + if (ret) { + goto end; + } + + ret = set_integer_field_value(timestamp_field, + timestamp); + if (ret) { + goto end; + } + } + } + +end: + bt_put(id_field); + bt_put(timestamp_field); + bt_put(mapped_clock_class); + return ret; +} + +int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, + struct bt_ctf_event *event) +{ + int ret = 0; + + if (!stream || !event || stream->pos.fd < 0) { + ret = -1; goto end; } - /* Make sure the event's payload is set */ - ret = bt_ctf_event_validate(event); - if (ret) { + /* + * The event is not supposed to have a parent stream at this + * point. The only other way an event can have a parent stream + * is if it was assigned when setting a packet to the event, + * in which case the packet's stream is not a writer stream, + * and thus the user is trying to append an event which belongs + * to another stream. + */ + if (event->base.parent) { + ret = -1; 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; - } + bt_object_set_parent(event, stream); + ret = auto_populate_event_header(stream, event); + if (ret) { + goto error; + } - event_context_copy = bt_ctf_field_copy(stream->event_context); - if (!event_context_copy) { - ret = -1; - goto end; - } + /* Make sure the various scopes of the event are set */ + ret = bt_ctf_event_validate(event); + if (ret) { + goto error; } - /* 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 @@ -544,14 +719,17 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, * 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; + +error: + /* + * Orphan the event; we were not successful in associating it to + * a stream. + */ + bt_object_set_parent(event, NULL); + return ret; } @@ -560,7 +738,7 @@ 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; } @@ -578,73 +756,31 @@ 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 || 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_put(field_type); - bt_get(field); bt_put(stream->packet_context); - stream->packet_context = field; + stream->packet_context = bt_get(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_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) { struct bt_ctf_field *packet_header = NULL; - if (!stream) { + if (!stream || stream->pos.fd < 0) { goto end; } @@ -663,21 +799,20 @@ int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream, struct bt_ctf_trace *trace = NULL; struct bt_ctf_field_type *field_type = NULL; - if (!stream || !field) { + if (!stream || 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 != trace->packet_header_type) { + if (bt_ctf_field_type_compare(field_type, trace->packet_header_type)) { ret = -1; goto end; } - bt_get(field); bt_put(stream->packet_header); - stream->packet_header = field; + stream->packet_header = bt_get(field); end: BT_PUT(trace); bt_put(field_type); @@ -701,7 +836,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; } @@ -841,10 +976,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; } @@ -883,9 +1017,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); @@ -916,12 +1047,13 @@ void bt_ctf_stream_destroy(struct bt_object *obj) if (stream->events) { g_ptr_array_free(stream->events, TRUE); } - if (stream->event_contexts) { - g_ptr_array_free(stream->event_contexts, TRUE); + + if (stream->name) { + g_string_free(stream->name, TRUE); } + bt_put(stream->packet_header); bt_put(stream->packet_context); - bt_put(stream->event_context); g_free(stream); } @@ -945,7 +1077,7 @@ int set_structure_field_integer(struct bt_ctf_field *structure, char *name, } /* Make sure the payload has not already been set. */ - if (!bt_ctf_field_validate(integer)) { + if (bt_ctf_field_is_set(integer)) { /* Payload already set, not an error */ goto end; } @@ -953,7 +1085,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 @@ -974,3 +1106,31 @@ end: bt_put(field_type); return ret; } + +const char *bt_ctf_stream_get_name(struct bt_ctf_stream *stream) +{ + const char *name = NULL; + + if (!stream) { + goto end; + } + + name = stream->name ? stream->name->str : NULL; + +end: + return name; +} + +int bt_ctf_stream_is_writer(struct bt_ctf_stream *stream) +{ + int ret = -1; + + if (!stream) { + goto end; + } + + ret = (stream->pos.fd >= 0); + +end: + return ret; +}