*/
struct ctx {
/* Trace IR trace being filled (owned by this) */
- struct bt_trace *trace;
+ struct bt_private_trace *trace;
/* CTF meta trace being filled (owned by this) */
struct ctf_trace_class *ctf_tc;
goto error;
}
- ctx->trace = bt_trace_create();
+ ctx->trace = bt_private_trace_create();
if (!ctx->trace) {
BT_LOGE_STR("Cannot create empty trace.");
goto error;
int signedness = 0;
struct ctf_node *expression;
uint64_t alignment = 0, size = 0;
- struct bt_clock_class *mapped_clock_class = NULL;
+ struct bt_private_clock_class *mapped_clock_class = NULL;
enum ctf_encoding encoding = CTF_ENCODING_NONE;
enum bt_field_class_integer_preferred_display_base base =
BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
int auto_map_field_to_trace_clock_class(struct ctx *ctx,
struct ctf_field_class *fc)
{
- struct bt_clock_class *clock_class_to_map_to = NULL;
+ struct bt_private_clock_class *clock_class_to_map_to = NULL;
struct ctf_field_class_int *int_fc = (void *) fc;
int ret = 0;
uint64_t clock_class_count;
* implicit one at 1 GHz, named `default`, and use this clock
* class.
*/
- clock_class_to_map_to = bt_clock_class_create();
+ clock_class_to_map_to = bt_private_clock_class_create();
BT_ASSERT(clock_class_to_map_to);
- ret = bt_clock_class_set_frequency(clock_class_to_map_to,
+ ret = bt_private_clock_class_set_frequency(clock_class_to_map_to,
UINT64_C(1000000000));
BT_ASSERT(ret == 0);
- ret = bt_clock_class_set_name(clock_class_to_map_to,
+ ret = bt_private_clock_class_set_name(clock_class_to_map_to,
"default");
BT_ASSERT(ret == 0);
g_ptr_array_add(ctx->ctf_tc->clock_classes,
static
int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- struct bt_clock_class *clock, int *set, int64_t *offset_seconds,
+ struct bt_private_clock_class *clock, int *set, int64_t *offset_seconds,
uint64_t *offset_cycles)
{
int ret = 0;
goto error;
}
- ret = bt_clock_class_set_name(clock, right);
+ ret = bt_private_clock_class_set_name(clock, right);
if (ret) {
_BT_LOGE_NODE(entry_node,
"cannot set clock class's name");
goto error;
}
- ret = bt_clock_class_set_uuid(clock, uuid);
+ ret = bt_private_clock_class_set_uuid(clock, uuid);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's UUID.");
goto error;
}
- ret = bt_clock_class_set_description(clock, right);
+ ret = bt_private_clock_class_set_description(clock, right);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's description.");
goto error;
}
- ret = bt_clock_class_set_frequency(clock, freq);
+ ret = bt_private_clock_class_set_frequency(clock, freq);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's frequency.");
goto error;
}
- ret = bt_clock_class_set_precision(clock, precision);
+ ret = bt_private_clock_class_set_precision(clock, precision);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's precision.");
goto error;
}
- ret = bt_clock_class_set_is_absolute(clock, ret);
+ ret = bt_private_clock_class_set_is_absolute(clock, ret);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's absolute flag.");
}
static
-void apply_clock_class_offset(struct ctx *ctx, struct bt_clock_class *clock)
+void apply_clock_class_offset(struct ctx *ctx,
+ struct bt_private_clock_class *clock)
{
int ret;
uint64_t freq;
offset_s_to_apply += extra_s;
}
- freq = bt_clock_class_get_frequency(clock);
- bt_clock_class_get_offset(clock, &cur_offset_s, &cur_offset_cycles);
+ freq = bt_clock_class_get_frequency(
+ bt_clock_class_borrow_from_private(clock));
+ bt_clock_class_get_offset(bt_clock_class_borrow_from_private(clock),
+ &cur_offset_s, &cur_offset_cycles);
/* Apply offsets */
cur_offset_s += offset_s_to_apply;
calibrate_clock_class_offsets(&cur_offset_s, &cur_offset_cycles, freq);
/* Set final offsets */
- ret = bt_clock_class_set_offset(clock, cur_offset_s, cur_offset_cycles);
+ ret = bt_private_clock_class_set_offset(clock, cur_offset_s, cur_offset_cycles);
BT_ASSERT(ret == 0);
end:
{
int ret = 0;
int set = 0;
- struct bt_clock_class *clock;
+ struct bt_private_clock_class *clock;
struct ctf_node *entry_node;
struct bt_list_head *decl_list = &clock_node->u.clock.declaration_list;
const char *clock_class_name;
clock_node->visited = TRUE;
/* CTF 1.8's default frequency for a clock class is 1 GHz */
- clock = bt_clock_class_create();
+ clock = bt_private_clock_class_create();
if (!clock) {
_BT_LOGE_NODE(clock_node,
"Cannot create default clock class.");
}
/* CTF: not absolute by default */
- ret = bt_clock_class_set_is_absolute(clock, BT_FALSE);
+ ret = bt_private_clock_class_set_is_absolute(clock, BT_FALSE);
if (ret) {
_BT_LOGE_NODE(clock_node,
"Cannot set clock class's absolute flag.");
goto end;
}
- clock_class_name = bt_clock_class_get_name(clock);
+ clock_class_name = bt_clock_class_get_name(
+ bt_clock_class_borrow_from_private(clock));
BT_ASSERT(clock_class_name);
if (ctx->is_lttng && strcmp(clock_class_name, "monotonic") == 0) {
/*
* it's a condition to be able to sort notifications
* from different sources.
*/
- ret = bt_clock_class_set_is_absolute(clock, BT_TRUE);
+ ret = bt_private_clock_class_set_is_absolute(clock, BT_TRUE);
if (ret) {
_BT_LOGE_NODE(clock_node,
"Cannot set clock class's absolute flag.");
* Adjust offsets so that the part in cycles is less than the
* frequency (move to the part in seconds).
*/
- freq = bt_clock_class_get_frequency(clock);
+ freq = bt_clock_class_get_frequency(
+ bt_clock_class_borrow_from_private(clock));
calibrate_clock_class_offsets(&offset_seconds, &offset_cycles, freq);
- BT_ASSERT(offset_cycles < bt_clock_class_get_frequency(clock));
- ret = bt_clock_class_set_offset(clock, offset_seconds, offset_cycles);
+ BT_ASSERT(offset_cycles < bt_clock_class_get_frequency(
+ bt_clock_class_borrow_from_private(clock)));
+ ret = bt_private_clock_class_set_offset(clock, offset_seconds, offset_cycles);
BT_ASSERT(ret == 0);
apply_clock_class_offset(ctx, clock);
g_ptr_array_add(ctx->ctf_tc->clock_classes, bt_object_get_ref(clock));
}
BT_HIDDEN
-struct bt_trace *ctf_visitor_generate_ir_get_ir_trace(
+struct bt_private_trace *ctf_visitor_generate_ir_get_ir_trace(
struct ctf_visitor_generate_ir *visitor)
{
struct ctx *ctx = (void *) visitor;
projects / babeltrace.git / blobdiff