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;
}
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;
}
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;
}
BT_HIDDEN
void bt_ctf_stream_update_clock_value(struct bt_ctf_stream *stream,
struct bt_ctf_field *value_field)
{
struct bt_ctf_field_type *value_type = NULL;
struct bt_ctf_clock *clock = NULL;
uint64_t requested_new_value;
uint64_t requested_new_value_mask;
uint64_t *cur_value;
uint64_t cur_value_masked;
int requested_new_value_size;
int ret;
assert(stream);
assert(clock);
assert(value_field);
value_type = bt_ctf_field_get_type(value_field);
assert(value_type);
clock = bt_ctf_field_type_integer_get_mapped_clock(value_type);
assert(clock);
requested_new_value_size =
bt_ctf_field_type_integer_get_size(value_type);
assert(requested_new_value_size > 0);
ret = bt_ctf_field_unsigned_integer_get_value(value_field,
&requested_new_value);
assert(!ret);
cur_value = g_hash_table_lookup(stream->clock_values, clock);
if (!cur_value) {
/*
* Updating the value of a clock which is not registered
* yet, so register it with the new value as its initial
* value.
*/
uint64_t *requested_new_value_ptr = g_new0(uint64_t, 1);
*requested_new_value_ptr = requested_new_value;
g_hash_table_insert(stream->clock_values, clock,
requested_new_value_ptr);
goto end;
}
/*
* Special case for a 64-bit new value, which is the limit
* of a clock value as of this version: overwrite the
* current value directly.
*/
if (requested_new_value_size == 64) {
*cur_value = requested_new_value;
goto end;
}
requested_new_value_mask = (1ULL << requested_new_value_size) - 1;
cur_value_masked = *cur_value & requested_new_value_mask;
if (requested_new_value < cur_value_masked) {
/*
* It looks like a wrap happened on the number of bits
* of the requested new value. Assume that the clock
* value wrapped only one time.
*/
*cur_value += requested_new_value_mask + 1;
}
/* Clear the low bits of the current clock value */
*cur_value &= ~requested_new_value_mask;
/* Set the low bits of the current clock value */
*cur_value |= requested_new_value;
end:
bt_put(clock);
bt_put(value_type);
}
