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; }