X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=8b60e1e86ddf5f10e846120ee58323872b0c5ac8;hb=9f476966aa40bd0de2cd0654623ea03f8a3254eb;hp=ce909bf4535696df0af262272d16159048519c9e;hpb=8bfa3f9cc64d97a164eb5fd2d9f9a31497d9e26d;p=babeltrace.git diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c index ce909bf4..8b60e1e8 100644 --- a/formats/ctf/ir/stream.c +++ b/formats/ctf/ir/stream.c @@ -38,20 +38,223 @@ #include #include #include +#include static void bt_ctf_stream_destroy(struct bt_ctf_ref *ref); static int set_structure_field_integer(struct bt_ctf_field *, char *, uint64_t); +static +int set_packet_header_magic(struct bt_ctf_stream *stream) +{ + int ret = 0; + struct bt_ctf_field_type *magic_field_type = NULL; + struct bt_ctf_field *magic_field = bt_ctf_field_structure_get_field( + stream->packet_header, "magic"); + + if (!magic_field) { + /* No magic field found. Not an error, skip. */ + goto end; + } + + if (!bt_ctf_field_validate(magic_field)) { + /* Value already set. Not an error, skip. */ + goto end; + } + + magic_field_type = bt_ctf_field_get_type(magic_field); + assert(magic_field_type); + + if (bt_ctf_field_type_get_type_id(magic_field_type) != + CTF_TYPE_INTEGER) { + /* Magic field is not an integer. Not an error, skip. */ + goto end; + } + + if (bt_ctf_field_type_integer_get_size(magic_field_type) != 32) { + /* + * Magic field is not of the expected size. + * Not an error, skip. + */ + goto end; + } + + ret = bt_ctf_field_type_integer_get_signed(magic_field_type); + assert(ret >= 0); + if (ret) { + ret = bt_ctf_field_signed_integer_set_value(magic_field, + (int64_t) 0xC1FC1FC1); + } else { + ret = bt_ctf_field_unsigned_integer_set_value(magic_field, + (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); + } + return ret; +} + +static +int set_packet_header_uuid(struct bt_ctf_stream *stream) +{ + int i, ret = 0; + 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( + stream->packet_header, "uuid"); + + if (!uuid_field) { + /* No uuid field found. Not an error, skip. */ + goto end; + } + + if (!bt_ctf_field_validate(uuid_field)) { + /* Value already set. Not an error, skip. */ + goto end; + } + + 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) { + /* UUID field is not an array. Not an error, skip. */ + goto end; + } + + if (bt_ctf_field_type_array_get_length(uuid_field_type) != 16) { + /* + * UUID field is not of the expected size. + * Not an error, skip. + */ + goto end; + } + + element_field_type = bt_ctf_field_type_array_get_element_type( + uuid_field_type); + assert(element_field_type); + if (bt_ctf_field_type_get_type_id(element_field_type) != + CTF_TYPE_INTEGER) { + /* UUID array elements are not integers. Not an error, skip */ + goto end; + } + + for (i = 0; i < 16; i++) { + struct bt_ctf_field *uuid_element = + bt_ctf_field_array_get_field(uuid_field, i); + + ret = bt_ctf_field_type_integer_get_signed(element_field_type); + assert(ret >= 0); + + if (ret) { + ret = bt_ctf_field_signed_integer_set_value( + uuid_element, (int64_t) stream->trace->uuid[i]); + } else { + ret = bt_ctf_field_unsigned_integer_set_value( + uuid_element, + (uint64_t) stream->trace->uuid[i]); + } + bt_ctf_field_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); + } + return ret; +} +static +int set_packet_header_stream_id(struct bt_ctf_stream *stream) +{ + int ret = 0; + uint32_t stream_id; + struct bt_ctf_field_type *stream_id_field_type = NULL; + struct bt_ctf_field *stream_id_field = bt_ctf_field_structure_get_field( + stream->packet_header, "stream_id"); + + if (!stream_id_field) { + /* No stream_id field found. Not an error, skip. */ + goto end; + } + + if (!bt_ctf_field_validate(stream_id_field)) { + /* Value already set. Not an error, skip. */ + goto end; + } + + 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) { + /* stream_id field is not an integer. Not an error, skip. */ + goto end; + } + + stream_id = stream->stream_class->id; + ret = bt_ctf_field_type_integer_get_signed(stream_id_field_type); + assert(ret >= 0); + if (ret) { + ret = bt_ctf_field_signed_integer_set_value(stream_id_field, + (int64_t) stream_id); + } else { + ret = bt_ctf_field_unsigned_integer_set_value(stream_id_field, + (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); + } + return ret; +} + +static +int set_packet_header(struct bt_ctf_stream *stream) +{ + int ret; + + ret = set_packet_header_magic(stream); + if (ret) { + goto end; + } + + ret = set_packet_header_uuid(stream); + if (ret) { + goto end; + } + + ret = set_packet_header_stream_id(stream); + if (ret) { + goto end; + } +end: + return ret; +} + BT_HIDDEN struct bt_ctf_stream *bt_ctf_stream_create( - struct bt_ctf_stream_class *stream_class) + struct bt_ctf_stream_class *stream_class, + struct bt_ctf_trace *trace) { int ret; struct bt_ctf_stream *stream = NULL; - if (!stream_class) { + if (!stream_class || !trace) { goto end; } @@ -60,6 +263,7 @@ struct bt_ctf_stream *bt_ctf_stream_create( goto end; } + stream->trace = trace; bt_ctf_ref_init(&stream->ref_count); stream->packet_context = bt_ctf_field_create( stream_class->packet_context_type); @@ -105,6 +309,22 @@ struct bt_ctf_stream *bt_ctf_stream_create( goto error_destroy; } } + + /* 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); + /* + * 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: @@ -113,35 +333,41 @@ error_destroy: } BT_HIDDEN -int bt_ctf_stream_set_flush_callback(struct bt_ctf_stream *stream, - flush_func callback, void *data) +int bt_ctf_stream_set_fd(struct bt_ctf_stream *stream, int fd) { - int ret = stream ? 0 : -1; + int ret = 0; - if (!stream) { + if (stream->pos.fd != -1) { + ret = -1; goto end; } - stream->flush.func = callback; - stream->flush.data = data; + ctf_init_pos(&stream->pos, NULL, fd, O_RDWR); + stream->pos.fd = fd; end: return ret; } BT_HIDDEN -int bt_ctf_stream_set_fd(struct bt_ctf_stream *stream, int fd) +void bt_ctf_stream_set_trace(struct bt_ctf_stream *stream, + struct bt_ctf_trace *trace) { - int ret = 0; + stream->trace = trace; +} - if (stream->pos.fd != -1) { - ret = -1; +struct bt_ctf_stream_class *bt_ctf_stream_get_class( + struct bt_ctf_stream *stream) +{ + struct bt_ctf_stream_class *stream_class = NULL; + + if (!stream) { goto end; } - ctf_init_pos(&stream->pos, NULL, fd, O_RDWR); - stream->pos.fd = fd; + stream_class = stream->stream_class; + bt_ctf_stream_class_get(stream_class); end: - return ret; + return stream_class; } int bt_ctf_stream_get_discarded_events_count( @@ -283,6 +509,12 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, goto end; } + 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) { goto end; @@ -329,10 +561,10 @@ struct bt_ctf_field *bt_ctf_stream_get_packet_context( } packet_context = stream->packet_context; -end: if (packet_context) { bt_ctf_field_get(packet_context); } +end: return packet_context; } @@ -405,12 +637,55 @@ end: 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) { + goto end; + } + + packet_header = stream->packet_header; + if (packet_header) { + bt_ctf_field_get(packet_header); + } +end: + return packet_header; +} + +int bt_ctf_stream_set_packet_header(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->trace->packet_header_type) { + ret = -1; + goto end; + } + + bt_ctf_field_get(field); + bt_ctf_field_put(stream->packet_header); + stream->packet_header = field; +end: + if (field_type) { + bt_ctf_field_type_put(field_type); + } + return ret; +} + 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; @@ -427,11 +702,21 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) goto end; } - if (stream->flush.func) { - stream->flush.func(stream, stream->flush.data); + ret = bt_ctf_field_validate(stream->packet_header); + if (ret) { + 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); + } + + 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( @@ -497,24 +782,24 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream) event->event_class); uint64_t timestamp = bt_ctf_event_get_timestamp(event); - ret = bt_ctf_field_reset(stream_class->event_header); + ret = bt_ctf_field_reset(event->event_header); if (ret) { goto end; } - ret = set_structure_field_integer(stream_class->event_header, + ret = set_structure_field_integer(event->event_header, "id", event_id); if (ret) { goto end; } - ret = set_structure_field_integer(stream_class->event_header, + ret = set_structure_field_integer(event->event_header, "timestamp", timestamp); 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; @@ -614,6 +899,9 @@ void bt_ctf_stream_destroy(struct bt_ctf_ref *ref) 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); } @@ -628,6 +916,7 @@ int set_structure_field_integer(struct bt_ctf_field *structure, char *name, uint64_t value) { int ret = 0; + struct bt_ctf_field_type *field_type = NULL; struct bt_ctf_field *integer = bt_ctf_field_structure_get_field(structure, name); @@ -647,8 +936,31 @@ int set_structure_field_integer(struct bt_ctf_field *structure, char *name, goto end; } - ret = bt_ctf_field_unsigned_integer_set_value(integer, value); + 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) { + /* + * The user most likely meant for us to populate this field + * automatically. However, we can only do this if the field + * is an integer. Return an error. + */ + ret = -1; + goto end; + } + + if (bt_ctf_field_type_integer_get_signed(field_type)) { + ret = bt_ctf_field_signed_integer_set_value(integer, + (int64_t) value); + } else { + ret = bt_ctf_field_unsigned_integer_set_value(integer, value); + } end: - bt_ctf_field_put(integer); + if (integer) { + bt_ctf_field_put(integer); + } + if (field_type) { + bt_ctf_field_type_put(field_type); + } return ret; }