static __maybe_unused int
value_set_string(struct ctf_writer *cw, struct bt_ctf_event *event,
const char *name, const char *string)
{
struct bt_ctf_field_type *type = cw->data.string;
struct bt_ctf_field *field;
int ret = 0;
field = bt_ctf_field_create(type);
if (!field) {
pr_err("failed to create a field %s\n", name);
return -1;
}
ret = string_set_value(field, string);
if (ret) {
pr_err("failed to set value %s\n", name);
goto err_put_field;
}
ret = bt_ctf_event_set_payload(event, name, field);
if (ret)
pr_err("failed to set payload %s\n", name);
err_put_field:
bt_ctf_field_put(field);
return ret;
}
static
int bt_ctf_field_string_serialize(struct bt_ctf_field *field,
struct ctf_stream_pos *pos)
{
size_t i;
int ret = 0;
struct bt_ctf_field_string *string = container_of(field,
struct bt_ctf_field_string, parent);
struct bt_ctf_field_type *character_type =
get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
struct bt_ctf_field *character = bt_ctf_field_create(character_type);
for (i = 0; i < string->payload->len + 1; i++) {
ret = bt_ctf_field_unsigned_integer_set_value(character,
(uint64_t) string->payload->str[i]);
if (ret) {
goto end;
}
ret = bt_ctf_field_integer_serialize(character, pos);
if (ret) {
goto end;
}
}
end:
bt_ctf_field_put(character);
bt_ctf_field_type_put(character_type);
return ret;
}
const char *bt_ctf_field_enumeration_get_mapping_name(
struct bt_ctf_field *field)
{
int ret;
const char *name = NULL;
struct bt_ctf_field *container = NULL;
struct bt_ctf_field_type *container_type = NULL;
struct bt_ctf_field_type_integer *integer_type = NULL;
struct bt_ctf_field_type_enumeration *enumeration_type = NULL;
container = bt_ctf_field_enumeration_get_container(field);
if (!container) {
goto end;
}
container_type = bt_ctf_field_get_type(container);
if (!container_type) {
goto error_put_container;
}
integer_type = container_of(container_type,
struct bt_ctf_field_type_integer, parent);
enumeration_type = container_of(field->type,
struct bt_ctf_field_type_enumeration, parent);
if (!integer_type->declaration.signedness) {
uint64_t value;
ret = bt_ctf_field_unsigned_integer_get_value(container,
&value);
if (ret) {
goto error_put_container_type;
}
name = bt_ctf_field_type_enumeration_get_mapping_name_unsigned(
enumeration_type, value);
} else {
int64_t value;
ret = bt_ctf_field_signed_integer_get_value(container,
&value);
if (ret) {
goto error_put_container_type;
}
name = bt_ctf_field_type_enumeration_get_mapping_name_signed(
enumeration_type, value);
}
error_put_container_type:
bt_ctf_field_type_put(container_type);
error_put_container:
bt_ctf_field_put(container);
end:
return name;
}
int bt_ctf_field_sequence_set_length(struct bt_ctf_field *field,
struct bt_ctf_field *length_field)
{
int ret = 0;
struct bt_ctf_field_type_integer *length_type;
struct bt_ctf_field_integer *length;
struct bt_ctf_field_sequence *sequence;
uint64_t sequence_length;
if (!field || !length_field) {
ret = -1;
goto end;
}
if (bt_ctf_field_type_get_type_id(length_field->type) !=
CTF_TYPE_INTEGER) {
ret = -1;
goto end;
}
length_type = container_of(length_field->type,
struct bt_ctf_field_type_integer, parent);
/* The length field must be unsigned */
if (length_type->declaration.signedness) {
ret = -1;
goto end;
}
length = container_of(length_field, struct bt_ctf_field_integer,
parent);
sequence_length = length->definition.value._unsigned;
sequence = container_of(field, struct bt_ctf_field_sequence, parent);
if (sequence->elements) {
g_ptr_array_free(sequence->elements, TRUE);
bt_ctf_field_put(sequence->length);
}
sequence->elements = g_ptr_array_sized_new((size_t)sequence_length);
if (!sequence->elements) {
ret = -1;
goto end;
}
g_ptr_array_set_free_func(sequence->elements,
(GDestroyNotify)bt_ctf_field_put);
g_ptr_array_set_size(sequence->elements, (size_t)sequence_length);
bt_ctf_field_get(length_field);
sequence->length = length_field;
end:
return ret;
}
static
void bt_ctf_field_sequence_destroy(struct bt_ctf_field *field)
{
struct bt_ctf_field_sequence *sequence;
if (!field) {
return;
}
sequence = container_of(field, struct bt_ctf_field_sequence, parent);
g_ptr_array_free(sequence->elements, TRUE);
bt_ctf_field_put(sequence->length);
g_free(sequence);
}
static
void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *field)
{
struct bt_ctf_field_enumeration *enumeration;
if (!field) {
return;
}
enumeration = container_of(field, struct bt_ctf_field_enumeration,
parent);
bt_ctf_field_put(enumeration->payload);
g_free(enumeration);
}
void bt_ctf_writer_destroy(struct bt_ctf_ref *ref)
{
struct bt_ctf_writer *writer;
if (!ref) {
return;
}
writer = container_of(ref, struct bt_ctf_writer, ref_count);
bt_ctf_writer_flush_metadata(writer);
if (writer->path) {
g_string_free(writer->path, TRUE);
}
if (writer->trace_dir_fd > 0) {
if (close(writer->trace_dir_fd)) {
perror("close");
abort();
}
}
if (writer->metadata_fd > 0) {
if (close(writer->metadata_fd)) {
perror("close");
abort();
}
}
if (writer->environment) {
g_ptr_array_free(writer->environment, TRUE);
}
if (writer->clocks) {
g_ptr_array_free(writer->clocks, TRUE);
}
if (writer->streams) {
g_ptr_array_free(writer->streams, TRUE);
}
if (writer->stream_classes) {
g_ptr_array_free(writer->stream_classes, TRUE);
}
bt_ctf_field_type_put(writer->trace_packet_header_type);
bt_ctf_field_put(writer->trace_packet_header);
g_free(writer);
}
BT_HIDDEN
int bt_ctf_field_structure_set_field(struct bt_ctf_field *field,
const char *name, struct bt_ctf_field *value)
{
int ret = 0;
GQuark field_quark;
struct bt_ctf_field_structure *structure;
struct bt_ctf_field_type *expected_field_type = NULL;
size_t index;
if (!field || !name || !value ||
bt_ctf_field_type_get_type_id(field->type) !=
CTF_TYPE_STRUCT) {
ret = -1;
goto end;
}
field_quark = g_quark_from_string(name);
structure = container_of(field, struct bt_ctf_field_structure, parent);
expected_field_type =
bt_ctf_field_type_structure_get_field_type_by_name(field->type,
name);
if (expected_field_type != value->type) {
ret = -1;
goto end;
}
if (!g_hash_table_lookup_extended(structure->field_name_to_index,
GUINT_TO_POINTER(field_quark), NULL, (gpointer *) &index)) {
goto end;
}
if (structure->fields->pdata[index]) {
bt_ctf_field_put(structure->fields->pdata[index]);
}
structure->fields->pdata[index] = value;
bt_ctf_field_get(value);
end:
if (expected_field_type) {
bt_ctf_field_type_put(expected_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 value_set(struct bt_ctf_field_type *type,
struct bt_ctf_event *event,
const char *name, u64 val)
{
struct bt_ctf_field *field;
bool sign = bt_ctf_field_type_integer_get_signed(type);
int ret;
field = bt_ctf_field_create(type);
if (!field) {
pr_err("failed to create a field %s\n", name);
return -1;
}
if (sign) {
ret = bt_ctf_field_signed_integer_set_value(field, val);
if (ret) {
pr_err("failed to set field value %s\n", name);
goto err;
}
} else {
ret = bt_ctf_field_unsigned_integer_set_value(field, val);
if (ret) {
pr_err("failed to set field value %s\n", name);
goto err;
}
}
ret = bt_ctf_event_set_payload(event, name, field);
if (ret) {
pr_err("failed to set payload %s\n", name);
goto err;
}
pr2(" SET [%s = %" PRIu64 "]\n", name, val);
err:
bt_ctf_field_put(field);
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;
}