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