BT_HIDDEN int bt_ctf_event_populate_event_header(struct bt_ctf_event *event) { int ret = 0; struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL; if (!event || event->frozen) { ret = -1; goto end; } id_field = bt_ctf_field_structure_get_field(event->event_header, "id"); if (id_field) { ret = set_integer_field_value(id_field, (uint64_t) bt_ctf_event_class_get_id( event->event_class)); if (ret) { goto end; } } timestamp_field = bt_ctf_field_structure_get_field(event->event_header, "timestamp"); if (timestamp_field) { struct bt_ctf_field_type *timestamp_field_type = bt_ctf_field_get_type(timestamp_field); struct bt_ctf_clock *mapped_clock; assert(timestamp_field_type); mapped_clock = bt_ctf_field_type_integer_get_mapped_clock( timestamp_field_type); bt_put(timestamp_field_type); if (mapped_clock) { int64_t timestamp; ret = bt_ctf_clock_get_time(mapped_clock, ×tamp); bt_put(mapped_clock); 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); return ret; }
int bt_ctf_stream_get_discarded_events_count( struct bt_ctf_stream *stream, uint64_t *count) { int64_t ret = 0; int field_signed; struct bt_ctf_field *events_discarded_field = NULL; struct bt_ctf_field_type *events_discarded_field_type = NULL; if (!stream || !count || !stream->packet_context) { ret = -1; goto end; } events_discarded_field = bt_ctf_field_structure_get_field( stream->packet_context, "events_discarded"); if (!events_discarded_field) { ret = -1; goto end; } events_discarded_field_type = bt_ctf_field_get_type( events_discarded_field); if (!events_discarded_field_type) { ret = -1; goto end; } field_signed = bt_ctf_field_type_integer_get_signed( events_discarded_field_type); if (field_signed < 0) { ret = field_signed; goto end; } if (field_signed) { int64_t signed_count; ret = bt_ctf_field_signed_integer_get_value( events_discarded_field, &signed_count); if (ret) { goto end; } if (signed_count < 0) { /* Invalid value */ ret = -1; goto end; } *count = (uint64_t) signed_count; } else { ret = bt_ctf_field_unsigned_integer_get_value( events_discarded_field, count); if (ret) { goto end; } } end: bt_put(events_discarded_field); bt_put(events_discarded_field_type); return ret; }
void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count) { int ret; int field_signed; uint64_t previous_count; uint64_t new_count; struct bt_ctf_field *events_discarded_field = NULL; struct bt_ctf_field_type *events_discarded_field_type = NULL; if (!stream || !stream->packet_context) { goto end; } ret = bt_ctf_stream_get_discarded_events_count(stream, &previous_count); if (ret) { goto end; } events_discarded_field = bt_ctf_field_structure_get_field( stream->packet_context, "events_discarded"); if (!events_discarded_field) { goto end; } events_discarded_field_type = bt_ctf_field_get_type( events_discarded_field); if (!events_discarded_field_type) { goto end; } field_signed = bt_ctf_field_type_integer_get_signed( events_discarded_field_type); if (field_signed < 0) { goto end; } new_count = previous_count + event_count; if (field_signed) { ret = bt_ctf_field_signed_integer_set_value( events_discarded_field, (int64_t) new_count); if (ret) { goto end; } } else { ret = bt_ctf_field_unsigned_integer_set_value( events_discarded_field, new_count); if (ret) { goto end; } } end: bt_put(events_discarded_field); bt_put(events_discarded_field_type); }
static 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); if (!structure || !name) { ret = -1; goto end; } if (!integer) { /* Field not found, not an error. */ goto end; } /* Make sure the payload has not already been set. */ if (!bt_ctf_field_validate(integer)) { /* Payload already set, not an error */ goto end; } 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_put(integer); bt_put(field_type); return ret; }
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: bt_put(magic_field); bt_put(magic_field_type); return ret; }
static void stream_flush_cb(struct bt_ctf_stream *stream, struct bt_ctf_writer *writer) { struct bt_ctf_field *stream_id; /* Start a new packet in the stream */ if (stream->flushed_packet_count) { /* ctf_init_pos has already initialized the first packet */ ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR); } stream_id = bt_ctf_field_structure_get_field( writer->trace_packet_header, "stream_id"); bt_ctf_field_unsigned_integer_set_value(stream_id, stream->stream_class->id); bt_ctf_field_put(stream_id); /* Write the trace_packet_header */ bt_ctf_field_serialize(writer->trace_packet_header, &stream->pos); }
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; }
struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name) { struct bt_ctf_field *field = NULL; if (!event) { goto end; } if (name) { field = bt_ctf_field_structure_get_field(event->fields_payload, name); } else { field = event->fields_payload; bt_get(field); } end: return field; }
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: bt_put(stream_id_field); bt_put(stream_id_field_type); return ret; }
static int init_trace_packet_header(struct bt_ctf_writer *writer) { size_t i; int ret = 0; struct bt_ctf_field *trace_packet_header = NULL, *magic = NULL, *uuid_array = NULL; struct bt_ctf_field_type *_uint32_t = get_field_type(FIELD_TYPE_ALIAS_UINT32_T); struct bt_ctf_field_type *_uint8_t = get_field_type(FIELD_TYPE_ALIAS_UINT8_T); struct bt_ctf_field_type *trace_packet_header_type = bt_ctf_field_type_structure_create(); struct bt_ctf_field_type *uuid_array_type = bt_ctf_field_type_array_create(_uint8_t, 16); if (!trace_packet_header_type || !uuid_array_type) { ret = -1; goto end; } ret = bt_ctf_field_type_set_byte_order(_uint32_t, (writer->byte_order == LITTLE_ENDIAN ? BT_CTF_BYTE_ORDER_LITTLE_ENDIAN : BT_CTF_BYTE_ORDER_BIG_ENDIAN)); if (ret) { goto end; } ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type, _uint32_t, "magic"); if (ret) { goto end; } ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type, uuid_array_type, "uuid"); if (ret) { goto end; } ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type, _uint32_t, "stream_id"); if (ret) { goto end; } trace_packet_header = bt_ctf_field_create(trace_packet_header_type); if (!trace_packet_header) { ret = -1; goto end; } magic = bt_ctf_field_structure_get_field(trace_packet_header, "magic"); ret = bt_ctf_field_unsigned_integer_set_value(magic, 0xC1FC1FC1); if (ret) { goto end; } uuid_array = bt_ctf_field_structure_get_field(trace_packet_header, "uuid"); for (i = 0; i < 16; i++) { struct bt_ctf_field *uuid_element = bt_ctf_field_array_get_field(uuid_array, i); ret = bt_ctf_field_unsigned_integer_set_value(uuid_element, writer->uuid[i]); bt_ctf_field_put(uuid_element); if (ret) { goto end; } } bt_ctf_field_type_put(writer->trace_packet_header_type); bt_ctf_field_put(writer->trace_packet_header); writer->trace_packet_header_type = trace_packet_header_type; writer->trace_packet_header = trace_packet_header; end: bt_ctf_field_type_put(uuid_array_type); bt_ctf_field_type_put(_uint32_t); bt_ctf_field_type_put(_uint8_t); bt_ctf_field_put(magic); bt_ctf_field_put(uuid_array); if (ret) { bt_ctf_field_type_put(trace_packet_header_type); bt_ctf_field_put(trace_packet_header); } 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_put(uuid_element); if (ret) { goto end; } } end: bt_put(uuid_field); bt_put(uuid_field_type); bt_put(element_field_type); return ret; }
BT_HIDDEN enum bt_component_status update_packet_context_field(FILE *err, struct bt_ctf_packet *writer_packet, const char *name, int64_t value) { enum bt_component_status ret; struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL; struct bt_ctf_field_type *struct_type = NULL, *field_type = NULL; struct bt_ctf_field *field = NULL, *writer_field = NULL; int nr_fields, i, int_ret; packet_context = bt_ctf_packet_get_context(writer_packet); if (!packet_context) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } struct_type = bt_ctf_field_get_type(packet_context); if (!struct_type) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } writer_packet_context = bt_ctf_packet_get_context(writer_packet); if (!writer_packet_context) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } nr_fields = bt_ctf_field_type_structure_get_field_count(struct_type); for (i = 0; i < nr_fields; i++) { const char *field_name; field = bt_ctf_field_structure_get_field_by_index( packet_context, i); if (!field) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } if (bt_ctf_field_type_structure_get_field(struct_type, &field_name, &field_type, i) < 0) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } if (strcmp(field_name, name)) { BT_PUT(field_type); BT_PUT(field); continue; } if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) { fprintf(err, "[error] Unexpected packet context field type\n"); goto error; } writer_field = bt_ctf_field_structure_get_field(writer_packet_context, field_name); if (!writer_field) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } int_ret = bt_ctf_field_unsigned_integer_set_value(writer_field, value); if (int_ret < 0) { fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } BT_PUT(writer_field); BT_PUT(field_type); BT_PUT(field); } ret = BT_COMPONENT_STATUS_OK; goto end; error: bt_put(writer_field); bt_put(field_type); bt_put(field); ret = BT_COMPONENT_STATUS_ERROR; end: bt_put(struct_type); bt_put(packet_context); return ret; }