/**
* A simple event has the following payload:
* - uint8_t payload_8;
* - uint16_t payload_16;
* - uint32_t payload_32;
*/
static struct bt_ctf_event_class *create_simple_event(const char *name)
{
int ret;
struct bt_ctf_event_class *event = NULL;
struct bt_ctf_field_type *payload = NULL;
assert(name);
event = bt_ctf_event_class_create(name);
if (!event) {
diag("Failed to create simple event");
goto error;
}
payload = create_integer_struct();
if (!payload) {
diag("Failed to initialize integer structure");
goto error;
}
ret = bt_ctf_event_class_set_payload_type(event, payload);
if (ret) {
diag("Failed to set simple event payload");
goto error;
}
end:
BT_PUT(payload);
return event;
error:
BT_PUT(event);
goto end;;
}
static struct bt_ctf_stream_class *create_sc2(void)
{
int ret;
struct bt_ctf_event_class *ec3 = NULL;
struct bt_ctf_stream_class *sc2 = NULL, *ret_stream = NULL;
sc2 = bt_ctf_stream_class_create("sc2");
if (!sc2) {
diag("Failed to create Stream Class");
goto error;
}
ec3 = create_simple_event("ec3");
if (!ec3) {
diag("Failed to create simple event EC3");
goto error;
}
ret = bt_ctf_stream_class_add_event_class(sc2, ec3);
if (ret) {
diag("Failed to add EC3 to SC2");
goto error;
}
ret_stream = bt_ctf_event_class_get_stream_class(ec3);
ok(ret_stream == sc2, "Get parent stream SC2 from EC3");
end:
BT_PUT(ret_stream);
BT_PUT(ec3);
return sc2;
error:
BT_PUT(sc2);
goto end;
}
struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name)
{
int ret;
struct bt_value *obj = NULL;
struct bt_ctf_event_class *event_class = NULL;
if (bt_ctf_validate_identifier(name)) {
goto error;
}
event_class = g_new0(struct bt_ctf_event_class, 1);
if (!event_class) {
goto error;
}
bt_object_init(event_class, bt_ctf_event_class_destroy);
event_class->fields = bt_ctf_field_type_structure_create();
if (!event_class->fields) {
goto error;
}
event_class->attributes = bt_ctf_attributes_create();
if (!event_class->attributes) {
goto error;
}
obj = bt_value_integer_create_init(-1);
if (!obj) {
goto error;
}
ret = bt_ctf_attributes_set_field_value(event_class->attributes,
"id", obj);
if (ret) {
goto error;
}
BT_PUT(obj);
obj = bt_value_string_create_init(name);
if (!obj) {
goto error;
}
ret = bt_ctf_attributes_set_field_value(event_class->attributes,
"name", obj);
if (ret) {
goto error;
}
BT_PUT(obj);
return event_class;
error:
BT_PUT(event_class);
BT_PUT(obj);
return event_class;
}
static
struct bt_value *bt_attributes_get_field_by_name(
struct bt_value *attr_obj, const char *name)
{
uint64_t i;
int64_t attr_size;
struct bt_value *value_obj = NULL;
struct bt_value *attr_field_name_obj = NULL;
attr_size = bt_value_array_size(attr_obj);
if (attr_size < 0) {
BT_LOGE("Cannot get array value's size: value-addr=%p",
attr_obj);
goto error;
}
for (i = 0; i < attr_size; ++i) {
int ret;
const char *field_name;
value_obj = bt_value_array_get(attr_obj, i);
if (!value_obj) {
BT_LOGE("Cannot get attributes object's array value's element by index: "
"value-addr=%p, index=%" PRIu64, attr_obj, i);
goto error;
}
attr_field_name_obj = bt_value_array_get(value_obj, 0);
if (!attr_field_name_obj) {
BT_LOGE("Cannot get attribute array value's element by index: "
"value-addr=%p, index=%" PRIu64,
value_obj, (int64_t) 0);
goto error;
}
ret = bt_value_string_get(attr_field_name_obj, &field_name);
if (ret) {
BT_LOGE("Cannot get raw value from string value: value-addr=%p",
attr_field_name_obj);
goto error;
}
if (!strcmp(field_name, name)) {
BT_PUT(attr_field_name_obj);
break;
}
BT_PUT(attr_field_name_obj);
BT_PUT(value_obj);
}
return value_obj;
error:
BT_PUT(attr_field_name_obj);
BT_PUT(value_obj);
return value_obj;
}
BT_HIDDEN
struct bt_ctf_packet *trimmer_new_packet(
struct trimmer_iterator *trim_it,
struct bt_ctf_packet *packet)
{
struct bt_ctf_stream *stream = NULL;
struct bt_ctf_field *writer_packet_context = NULL;
struct bt_ctf_packet *writer_packet = NULL;
int int_ret;
stream = bt_ctf_packet_get_stream(packet);
if (!stream) {
fprintf(trim_it->err, "[error] %s in %s:%d\n",
__func__, __FILE__, __LINE__);
goto error;
}
/*
* If a packet was already opened, close it and remove it from
* the HT.
*/
writer_packet = lookup_packet(trim_it, packet);
if (writer_packet) {
g_hash_table_remove(trim_it->packet_map, packet);
BT_PUT(writer_packet);
}
writer_packet = insert_new_packet(trim_it, packet, stream);
if (!writer_packet) {
fprintf(trim_it->err, "[error] %s in %s:%d\n",
__func__, __FILE__, __LINE__);
goto error;
}
bt_get(writer_packet);
writer_packet_context = ctf_copy_packet_context(trim_it->err, packet,
stream);
if (!writer_packet_context) {
fprintf(trim_it->err, "[error] %s in %s:%d\n",
__func__, __FILE__, __LINE__);
goto error;
}
int_ret = bt_ctf_packet_set_context(writer_packet, writer_packet_context);
if (int_ret) {
fprintf(trim_it->err, "[error] %s in %s:%d\n",
__func__, __FILE__, __LINE__);
goto error;
}
goto end;
error:
BT_PUT(writer_packet);
end:
bt_put(writer_packet_context);
bt_put(stream);
return writer_packet;
}
static void create_user_full(struct user *user)
{
char trace_path[] = "/tmp/ctfwriter_XXXXXX";
struct bt_ctf_field_type *ft;
struct bt_ctf_field *field;
struct bt_ctf_clock *clock;
int ret;
if (!bt_mkdtemp(trace_path)) {
perror("# perror");
}
user->writer = bt_ctf_writer_create(trace_path);
assert(user->writer);
user->tc = bt_ctf_writer_get_trace(user->writer);
assert(user->tc);
user->sc = bt_ctf_stream_class_create("sc");
assert(user->sc);
clock = bt_ctf_clock_create("the_clock");
assert(clock);
ret = bt_ctf_stream_class_set_clock(user->sc, clock);
assert(!ret);
ret = bt_ctf_clock_set_value(clock, 23);
assert(!ret);
BT_PUT(clock);
user->stream = bt_ctf_writer_create_stream(user->writer, user->sc);
assert(user->stream);
user->ec = bt_ctf_event_class_create("ec");
assert(user->ec);
ft = create_integer_struct();
assert(ft);
ret = bt_ctf_event_class_set_payload_type(user->ec, ft);
BT_PUT(ft);
assert(!ret);
ret = bt_ctf_stream_class_add_event_class(user->sc, user->ec);
assert(!ret);
user->event = bt_ctf_event_create(user->ec);
assert(user->event);
field = bt_ctf_event_get_payload(user->event, "payload_8");
assert(field);
ret = bt_ctf_field_unsigned_integer_set_value(field, 10);
assert(!ret);
BT_PUT(field);
field = bt_ctf_event_get_payload(user->event, "payload_16");
assert(field);
ret = bt_ctf_field_unsigned_integer_set_value(field, 20);
assert(!ret);
BT_PUT(field);
field = bt_ctf_event_get_payload(user->event, "payload_32");
assert(field);
ret = bt_ctf_field_unsigned_integer_set_value(field, 30);
assert(!ret);
BT_PUT(field);
ret = bt_ctf_stream_append_event(user->stream, user->event);
assert(!ret);
recursive_rmdir(trace_path);
}
static
void bt_notification_event_destroy(struct bt_object *obj)
{
struct bt_notification_event *notification =
(struct bt_notification_event *) obj;
BT_PUT(notification->event);
BT_PUT(notification->cc_prio_map);
g_free(notification);
}
/**
* Returns a structure containing the following fields:
* - uint8_t payload_8;
* - uint16_t payload_16;
* - uint32_t payload_32;
*/
static struct bt_ctf_field_type *create_integer_struct(void)
{
int ret;
struct bt_ctf_field_type *structure = NULL;
struct bt_ctf_field_type *ui8 = NULL, *ui16 = NULL, *ui32 = NULL;
structure = bt_ctf_field_type_structure_create();
if (!structure) {
goto error;
}
ui8 = bt_ctf_field_type_integer_create(8);
if (!ui8) {
diag("Failed to create uint8_t type");
goto error;
}
ret = bt_ctf_field_type_structure_add_field(structure, ui8,
"payload_8");
if (ret) {
diag("Failed to add uint8_t to structure");
goto error;
}
ui16 = bt_ctf_field_type_integer_create(16);
if (!ui16) {
diag("Failed to create uint16_t type");
goto error;
}
ret = bt_ctf_field_type_structure_add_field(structure, ui16,
"payload_16");
if (ret) {
diag("Failed to add uint16_t to structure");
goto error;
}
ui32 = bt_ctf_field_type_integer_create(32);
if (!ui32) {
diag("Failed to create uint32_t type");
goto error;
}
ret = bt_ctf_field_type_structure_add_field(structure, ui32,
"payload_32");
if (ret) {
diag("Failed to add uint32_t to structure");
goto error;
}
end:
BT_PUT(ui8);
BT_PUT(ui16);
BT_PUT(ui32);
return structure;
error:
BT_PUT(structure);
goto end;
}
static struct bt_ctf_stream_class *create_sc1(void)
{
int ret;
struct bt_ctf_event_class *ec1 = NULL, *ec2 = NULL;
struct bt_ctf_stream_class *sc1 = NULL, *ret_stream = NULL;
sc1 = bt_ctf_stream_class_create("sc1");
if (!sc1) {
diag("Failed to create Stream Class");
goto error;
}
ec1 = create_complex_event("ec1");
if (!ec1) {
diag("Failed to create complex event EC1");
goto error;
}
ret = bt_ctf_stream_class_add_event_class(sc1, ec1);
if (ret) {
diag("Failed to add EC1 to SC1");
goto error;
}
ec2 = create_simple_event("ec2");
if (!ec2) {
diag("Failed to create simple event EC2");
goto error;
}
ret = bt_ctf_stream_class_add_event_class(sc1, ec2);
if (ret) {
diag("Failed to add EC1 to SC1");
goto error;
}
ret_stream = bt_ctf_event_class_get_stream_class(ec1);
ok(ret_stream == sc1, "Get parent stream SC1 from EC1");
BT_PUT(ret_stream);
ret_stream = bt_ctf_event_class_get_stream_class(ec2);
ok(ret_stream == sc1, "Get parent stream SC1 from EC2");
end:
BT_PUT(ret_stream);
BT_PUT(ec1);
BT_PUT(ec2);
return sc1;
error:
BT_PUT(sc1);
goto end;
}
BT_HIDDEN
int bt_ctf_event_set_packet(struct bt_ctf_event *event,
struct bt_ctf_packet *packet)
{
struct bt_ctf_stream_class *event_stream_class = NULL;
struct bt_ctf_stream_class *packet_stream_class = NULL;
struct bt_ctf_stream *stream = NULL;
int ret = 0;
if (!event || !packet || event->frozen) {
ret = -1;
goto end;
}
/*
* Make sure the new packet was created by this event's
* stream, if it is set.
*/
stream = bt_ctf_event_get_stream(event);
if (stream) {
if (packet->stream != stream) {
ret = -1;
goto end;
}
} else {
event_stream_class =
bt_ctf_event_class_get_stream_class(event->event_class);
packet_stream_class =
bt_ctf_stream_get_class(packet->stream);
assert(event_stream_class);
assert(packet_stream_class);
if (event_stream_class != packet_stream_class) {
ret = -1;
goto end;
}
}
bt_get(packet);
BT_MOVE(event->packet, packet);
end:
BT_PUT(stream);
BT_PUT(event_stream_class);
BT_PUT(packet_stream_class);
return ret;
}
struct bt_config *bt_config_cli_args_create_with_default(int argc,
const char *argv[], int *retcode)
{
struct bt_value *initial_plugin_paths;
struct bt_config *cfg = NULL;
int ret;
initial_plugin_paths = bt_value_array_create();
if (!initial_plugin_paths) {
goto error;
}
ret = bt_config_append_plugin_paths(initial_plugin_paths,
CONFIG_IN_TREE_PLUGIN_PATH);
if (ret) {
goto error;
}
cfg = bt_config_cli_args_create(argc, argv, retcode, true, true,
BT_ENABLE_DEBUG_INFO == 0, initial_plugin_paths);
goto end;
error:
*retcode = 1;
BT_PUT(cfg);
end:
bt_put(initial_plugin_paths);
return cfg;
}
BT_HIDDEN
int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream,
struct bt_ctf_field *field)
{
int ret = 0;
struct bt_ctf_trace *trace = NULL;
struct bt_ctf_field_type *field_type = NULL;
if (!stream || !field || 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 (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;
end:
BT_PUT(trace);
bt_put(field_type);
return ret;
}
BT_HIDDEN
struct bt_value *bt_attributes_get_field_value_by_name(
struct bt_value *attr_obj, const char *name)
{
struct bt_value *value_obj = NULL;
struct bt_value *attr_field_obj = NULL;
if (!attr_obj || !name) {
BT_LOGW("Invalid parameter: attributes object or name is NULL: "
"value-addr=%p, name-addr=%p", attr_obj, name);
goto end;
}
attr_field_obj = bt_attributes_get_field_by_name(attr_obj, name);
if (!attr_field_obj) {
BT_LOGD("Cannot find attributes object's field by name: "
"value-addr=%p, name=\"%s\"", attr_obj, name);
goto end;
}
value_obj = bt_value_array_get(attr_field_obj,
BT_ATTR_VALUE_INDEX);
if (!value_obj) {
BT_LOGE("Cannot get attribute array value's element by index: "
"value-addr=%p, index=%" PRIu64, attr_field_obj,
(uint64_t) BT_ATTR_VALUE_INDEX);
}
end:
BT_PUT(attr_field_obj);
return value_obj;
}
struct bt_ctf_clock *bt_ctf_clock_create(const char *name)
{
int ret;
struct bt_ctf_clock *clock = NULL;
clock = _bt_ctf_clock_create();
if (!clock) {
goto error;
}
ret = bt_ctf_clock_set_name(clock, name);
if (ret) {
goto error;
}
ret = bt_uuid_generate(clock->uuid);
if (ret) {
goto error;
}
clock->uuid_set = 1;
return clock;
error:
BT_PUT(clock);
return clock;
}
BT_HIDDEN
int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
struct bt_ctf_field *stream_event_context)
{
int ret = 0;
struct bt_ctf_field_type *field_type = NULL;
struct bt_ctf_stream_class *stream_class = NULL;
if (!event || !stream_event_context || event->frozen) {
ret = -1;
goto end;
}
stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
/*
* We should not have been able to create the event without associating
* the event class to a stream class.
*/
assert(stream_class);
field_type = bt_ctf_field_get_type(stream_event_context);
if (bt_ctf_field_type_compare(field_type,
stream_class->event_context_type)) {
ret = -1;
goto end;
}
bt_get(stream_event_context);
BT_MOVE(event->stream_event_context, stream_event_context);
end:
BT_PUT(stream_class);
bt_put(field_type);
return ret;
}
struct bt_ctf_clock *bt_ctf_clock_create(const char *name)
{
int ret;
struct bt_ctf_clock *clock = NULL;
clock = _bt_ctf_clock_create();
if (!clock) {
goto error;
}
ret = bt_ctf_clock_set_name(clock, name);
if (ret) {
goto error;
}
ret = bt_uuid_generate(clock->uuid);
if (ret) {
goto error;
}
/*
* For backward compatibility reasons, a fresh clock can have
* a value because it could be added to a trace created by a
* CTF writer. As soon as this clock is added to a non-writer
* trace, then its value/time functions will be disabled.
*/
clock->has_value = 1;
clock->uuid_set = 1;
return clock;
error:
BT_PUT(clock);
return clock;
}
BT_HIDDEN
int bt_ctf_event_class_set_stream_id(struct bt_ctf_event_class *event_class,
uint32_t stream_id)
{
int ret = 0;
struct bt_value *obj;
obj = bt_value_integer_create_init(stream_id);
if (!obj) {
ret = -1;
goto end;
}
ret = bt_ctf_attributes_set_field_value(event_class->attributes,
"stream_id", obj);
if (event_class->frozen) {
bt_ctf_attributes_freeze(event_class->attributes);
}
end:
BT_PUT(obj);
return ret;
}
BT_HIDDEN
struct bt_value *bt_attributes_get_field_value(struct bt_value *attr_obj,
uint64_t index)
{
struct bt_value *value_obj = NULL;
struct bt_value *attr_field_obj = NULL;
if (!attr_obj) {
BT_LOGW_STR("Invalid parameter: attributes object is NULL.");
goto end;
}
attr_field_obj = bt_value_array_get(attr_obj, index);
if (!attr_field_obj) {
BT_LOGE("Cannot get attributes object's array value's element by index: "
"value-addr=%p, index=%" PRIu64, attr_obj, index);
goto end;
}
value_obj = bt_value_array_get(attr_field_obj,
BT_ATTR_VALUE_INDEX);
if (!value_obj) {
BT_LOGE("Cannot get attribute array value's element by index: "
"value-addr=%p, index=%" PRIu64, attr_field_obj,
(uint64_t) BT_ATTR_VALUE_INDEX);
}
end:
BT_PUT(attr_field_obj);
return value_obj;
}
BT_HIDDEN
int64_t bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class)
{
struct bt_value *obj = NULL;
int64_t ret = 0;
if (!event_class) {
ret = -1;
goto end;
}
obj = bt_ctf_attributes_get_field_value(event_class->attributes,
BT_CTF_EVENT_CLASS_ATTR_ID_INDEX);
if (!obj) {
goto end;
}
if (bt_value_integer_get(obj, &ret)) {
ret = -1;
}
if (ret < 0) {
/* means ID is not set */
ret = -1;
goto end;
}
end:
BT_PUT(obj);
return ret;
}
int ctf_fs_metadata_set_trace(struct ctf_fs_trace *ctf_fs_trace,
struct ctf_fs_metadata_config *config)
{
int ret = 0;
struct ctf_fs_file *file = NULL;
struct ctf_metadata_decoder *metadata_decoder = NULL;
struct ctf_metadata_decoder_config decoder_config = {
.clock_class_offset_s = config ? config->clock_class_offset_s : 0,
.clock_class_offset_ns = config ? config->clock_class_offset_ns : 0,
};
file = get_file(ctf_fs_trace->path->str);
if (!file) {
BT_LOGE("Cannot create metadata file object");
ret = -1;
goto end;
}
metadata_decoder = ctf_metadata_decoder_create(
config ? &decoder_config : NULL,
ctf_fs_trace->name->str);
if (!metadata_decoder) {
BT_LOGE("Cannot create metadata decoder object");
ret = -1;
goto end;
}
ret = ctf_metadata_decoder_decode(metadata_decoder, file->fp);
if (ret) {
BT_LOGE("Cannot decode metadata file");
goto end;
}
ctf_fs_trace->metadata->trace = ctf_metadata_decoder_get_trace(
metadata_decoder);
assert(ctf_fs_trace->metadata->trace);
end:
ctf_fs_file_destroy(file);
ctf_metadata_decoder_destroy(metadata_decoder);
return ret;
}
int ctf_fs_metadata_init(struct ctf_fs_metadata *metadata)
{
/* Nothing to initialize for the moment. */
return 0;
}
void ctf_fs_metadata_fini(struct ctf_fs_metadata *metadata)
{
if (metadata->text) {
free(metadata->text);
}
if (metadata->trace) {
BT_PUT(metadata->trace);
}
}
static
void stack_entry_free_func(gpointer data)
{
struct stack_entry *entry = data;
BT_PUT(entry->base_type);
g_free(entry);
}
/**
* A complex event has the following payload:
* - uint8_t payload_8;
* - uint16_t payload_16;
* - uint32_t payload_32;
* - struct payload_struct:
* - uint8_t payload_8;
* - uint16_t payload_16;
* - uint32_t payload_32;
*/
static struct bt_ctf_event_class *create_complex_event(const char *name)
{
int ret;
struct bt_ctf_event_class *event = NULL;
struct bt_ctf_field_type *inner = NULL, *outer = NULL;
assert(name);
event = bt_ctf_event_class_create(name);
if (!event) {
diag("Failed to create complex event");
goto error;
}
outer = create_integer_struct();
if (!outer) {
diag("Failed to initialize integer structure");
goto error;
}
inner = create_integer_struct();
if (!inner) {
diag("Failed to initialize integer structure");
goto error;
}
ret = bt_ctf_field_type_structure_add_field(outer, inner,
"payload_struct");
if (ret) {
diag("Failed to add inner structure to outer structure");
goto error;
}
ret = bt_ctf_event_class_set_payload_type(event, outer);
if (ret) {
diag("Failed to set complex event payload");
goto error;
}
end:
BT_PUT(inner);
BT_PUT(outer);
return event;
error:
BT_PUT(event);
goto end;;
}
static
void bt_notification_packet_end_destroy(struct bt_object *obj)
{
struct bt_notification_packet_end *notification =
(struct bt_notification_packet_end *) obj;
BT_PUT(notification->packet);
g_free(notification);
}
int bt_ctf_trace_set_environment_field_string(struct bt_ctf_trace *trace,
const char *name, const char *value)
{
int ret = 0;
struct bt_value *env_value_string_obj = NULL;
if (!trace || !name || !value) {
ret = -1;
goto end;
}
if (trace->frozen) {
/*
* New environment fields may be added to a frozen trace,
* but existing fields may not be changed.
*/
struct bt_value *attribute =
bt_ctf_attributes_get_field_value_by_name(
trace->environment, name);
if (attribute) {
BT_PUT(attribute);
ret = -1;
goto end;
}
}
env_value_string_obj = bt_value_string_create_init(value);
if (!env_value_string_obj) {
ret = -1;
goto end;
}
if (trace->frozen) {
bt_value_freeze(env_value_string_obj);
}
ret = bt_ctf_trace_set_environment_field(trace, name,
env_value_string_obj);
end:
BT_PUT(env_value_string_obj);
return ret;
}
void bt_btr_destroy(struct bt_btr *btr)
{
if (btr->stack) {
stack_destroy(btr->stack);
}
BT_LOGD("Destroying BTR: addr=%p", btr);
BT_PUT(btr->cur_basic_field_type);
g_free(btr);
}
static
void reset(struct bt_btr *btr)
{
BT_LOGD("Resetting BTR: addr=%p", btr);
stack_clear(btr->stack);
BT_PUT(btr->cur_basic_field_type);
stitch_reset(btr);
btr->buf.addr = NULL;
btr->last_bo = BT_BYTE_ORDER_UNKNOWN;
}
BT_HIDDEN
const char *bt_attributes_get_field_name(struct bt_value *attr_obj,
uint64_t index)
{
int rc;
const char *ret = NULL;
struct bt_value *attr_field_obj = NULL;
struct bt_value *attr_field_name_obj = NULL;
if (!attr_obj) {
BT_LOGW_STR("Invalid parameter: attributes object is NULL.");
goto end;
}
attr_field_obj = bt_value_array_get(attr_obj, index);
if (!attr_field_obj) {
BT_LOGE("Cannot get attributes object's array value's element by index: "
"value-addr=%p, index=%" PRIu64, attr_obj, index);
goto end;
}
attr_field_name_obj = bt_value_array_get(attr_field_obj,
BT_ATTR_NAME_INDEX);
if (!attr_field_name_obj) {
BT_LOGE("Cannot get attribute array value's element by index: "
"value-addr=%p, index=%" PRIu64, attr_field_obj,
(uint64_t) BT_ATTR_NAME_INDEX);
goto end;
}
rc = bt_value_string_get(attr_field_name_obj, &ret);
if (rc) {
BT_LOGE("Cannot get raw value from string value: value-addr=%p",
attr_field_name_obj);
ret = NULL;
}
end:
BT_PUT(attr_field_name_obj);
BT_PUT(attr_field_obj);
return ret;
}
static struct bt_ctf_trace *create_tc1(void)
{
int ret;
struct bt_ctf_trace *tc1 = NULL;
struct bt_ctf_stream_class *sc1 = NULL, *sc2 = NULL;
tc1 = bt_ctf_trace_create();
if (!tc1) {
diag("bt_ctf_trace_create returned NULL");
goto error;
}
sc1 = create_sc1();
ok(sc1, "Create SC1");
if (!sc1) {
goto error;
}
ret = bt_ctf_trace_add_stream_class(tc1, sc1);
ok(!ret, "Add SC1 to TC1");
if (ret) {
goto error;
}
sc2 = create_sc2();
ok(sc2, "Create SC2");
if (!sc2) {
goto error;
}
ret = bt_ctf_trace_add_stream_class(tc1, sc2);
ok(!ret, "Add SC2 to TC1");
if (ret) {
goto error;
}
end:
BT_PUT(sc1);
BT_PUT(sc2);
return tc1;
error:
BT_PUT(tc1);
goto end;
}
struct bt_ctf_packet *bt_ctf_packet_create(
struct bt_ctf_stream *stream)
{
struct bt_ctf_packet *packet = NULL;
struct bt_ctf_stream_class *stream_class = NULL;
struct bt_ctf_trace *trace = NULL;
if (!stream || stream->pos.fd >= 0) {
goto end;
}
stream_class = bt_ctf_stream_get_class(stream);
assert(stream_class);
trace = bt_ctf_stream_class_get_trace(stream_class);
assert(trace);
packet = g_new0(struct bt_ctf_packet, 1);
if (!packet) {
goto end;
}
bt_object_init(packet, bt_ctf_packet_destroy);
packet->stream = bt_get(stream);
packet->header = bt_ctf_field_create(trace->packet_header_type);
if (!packet->header) {
BT_PUT(packet);
goto end;
}
packet->context = bt_ctf_field_create(
stream->stream_class->packet_context_type);
if (!packet->context) {
BT_PUT(packet);
goto end;
}
end:
BT_PUT(trace);
BT_PUT(stream_class);
return packet;
}
BT_HIDDEN
int bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class,
uint32_t id)
{
int ret = 0;
struct bt_value *obj = NULL;
struct bt_ctf_stream_class *stream_class = NULL;
if (!event_class) {
ret = -1;
goto end;
}
stream_class = bt_ctf_event_class_get_stream_class(event_class);
if (stream_class) {
/*
* We don't allow changing the id if the event class has already
* been added to a stream class.
*/
ret = -1;
goto end;
}
obj = bt_ctf_attributes_get_field_value(event_class->attributes,
BT_CTF_EVENT_CLASS_ATTR_ID_INDEX);
if (!obj) {
goto end;
}
if (bt_value_integer_set(obj, id)) {
ret = -1;
goto end;
}
end:
BT_PUT(obj);
BT_PUT(stream_class);
return ret;
}
