src/ctf-writer/clock.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
   6  *
   7  * Babeltrace CTF writer - Clock
   8  */
   9
  10 #define BT_LOG_TAG "CTF-WRITER/CLOCK"
  11 #include "logging.h"
  12
  13 #include "common/assert.h"
  14 #include "common/uuid.h"
  15 #include "compat/compiler.h"
  16 #include <babeltrace2-ctf-writer/utils.h>
  17 #include <babeltrace2-ctf-writer/object.h>
  18 #include <inttypes.h>
  19
  20 #include "clock-class.h"
  21 #include "clock.h"
  22 #include "object.h"
  23 #include "writer.h"
  24
  25 static
  26 void bt_ctf_clock_destroy(struct bt_ctf_object *obj);
  27
  28 struct bt_ctf_clock *bt_ctf_clock_create(const char *name)
  29 {
  30         int ret;
  31         struct bt_ctf_clock *clock = NULL;
  32         bt_uuid_t cc_uuid;
  33
  34         BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
  35         clock = g_new0(struct bt_ctf_clock, 1);
  36         if (!clock) {
  37                 goto error;
  38         }
  39
  40         bt_ctf_object_init_shared(&clock->base, bt_ctf_clock_destroy);
  41         clock->value = 0;
  42
  43         /* Pre-2.0.0 backward compatibility: default frequency is 1 GHz */
  44         clock->clock_class = (void *) bt_ctf_clock_class_create(name, 1000000000);
  45         if (!clock->clock_class) {
  46                 goto error;
  47         }
  48
  49         /* Automatically set clock class's UUID. */
  50         bt_uuid_generate(cc_uuid);
  51
  52         ret = bt_ctf_clock_class_set_uuid(clock->clock_class, cc_uuid);
  53         BT_ASSERT_DBG(ret == 0);
  54         return clock;
  55
  56 error:
  57         BT_CTF_OBJECT_PUT_REF_AND_RESET(clock);
  58         return clock;
  59 }
  60
  61 const char *bt_ctf_clock_get_name(struct bt_ctf_clock *clock)
  62 {
  63         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  64         return bt_ctf_clock_class_get_name(clock->clock_class);
  65 }
  66
  67 const char *bt_ctf_clock_get_description(struct bt_ctf_clock *clock)
  68 {
  69         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  70         return bt_ctf_clock_class_get_description(clock->clock_class);
  71 }
  72
  73 int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc)
  74 {
  75         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  76         return bt_ctf_clock_class_set_description(clock->clock_class,
  77                 desc);
  78 }
  79
  80 uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock)
  81 {
  82         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  83         return bt_ctf_clock_class_get_frequency(clock->clock_class);
  84 }
  85
  86 int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq)
  87 {
  88         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  89         return bt_ctf_clock_class_set_frequency(clock->clock_class,
  90                 freq);
  91 }
  92
  93 uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock)
  94 {
  95         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  96         return bt_ctf_clock_class_get_precision(clock->clock_class);
  97 }
  98
  99 int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision)
 100 {
 101         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 102         return bt_ctf_clock_class_set_precision(clock->clock_class,
 103                 precision);
 104 }
 105
 106 int bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock, int64_t *offset_s)
 107 {
 108         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 109         return bt_ctf_clock_class_get_offset_s(clock->clock_class,
 110                 offset_s);
 111 }
 112
 113 int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, int64_t offset_s)
 114 {
 115         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 116         return bt_ctf_clock_class_set_offset_s(clock->clock_class,
 117                 offset_s);
 118 }
 119
 120 int bt_ctf_clock_get_offset(struct bt_ctf_clock *clock, int64_t *offset)
 121 {
 122         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 123         return bt_ctf_clock_class_get_offset_cycles(clock->clock_class,
 124                 offset);
 125 }
 126
 127 int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, int64_t offset)
 128 {
 129         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 130         return bt_ctf_clock_class_set_offset_cycles(clock->clock_class,
 131                 offset);
 132 }
 133
 134 int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock)
 135 {
 136         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 137         return bt_ctf_clock_class_is_absolute(clock->clock_class);
 138 }
 139
 140 int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute)
 141 {
 142         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 143         return bt_ctf_clock_class_set_is_absolute(clock->clock_class,
 144                 is_absolute);
 145 }
 146
 147 const uint8_t *bt_ctf_clock_get_uuid(struct bt_ctf_clock *clock)
 148 {
 149         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 150         return bt_ctf_clock_class_get_uuid(clock->clock_class);
 151 }
 152
 153 int bt_ctf_clock_set_uuid(struct bt_ctf_clock *clock, const uint8_t *uuid)
 154 {
 155         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 156         return bt_ctf_clock_class_set_uuid(clock->clock_class, uuid);
 157 }
 158
 159 int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, int64_t time)
 160 {
 161         int64_t value;
 162         struct bt_ctf_clock_class *cc;
 163
 164         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 165         cc = clock->clock_class;
 166
 167         /* Common case where cycles are actually nanoseconds */
 168         if (cc->frequency == 1000000000) {
 169                 value = time;
 170         } else {
 171                 value = (uint64_t) (((double) time *
 172                         (double) cc->frequency) / 1e9);
 173         }
 174
 175         BT_CTF_ASSERT_PRE(clock->value <= value,
 176                 "CTF writer clock value must be updated monotonically: "
 177                 "prev-value=%" PRId64 ", new-value=%" PRId64,
 178                 clock->value, value);
 179         clock->value = value;
 180         return 0;
 181 }
 182
 183 BT_HIDDEN
 184 int bt_ctf_clock_get_value(struct bt_ctf_clock *clock, uint64_t *value)
 185 {
 186         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 187         BT_CTF_ASSERT_PRE_NON_NULL(value, "Value");
 188         *value = clock->value;
 189         return 0;
 190 }
 191
 192 static
 193 void bt_ctf_clock_destroy(struct bt_ctf_object *obj)
 194 {
 195         struct bt_ctf_clock *clock;
 196
 197         clock = container_of(obj, struct bt_ctf_clock, base);
 198         bt_ctf_object_put_ref(clock->clock_class);
 199         g_free(clock);
 200 }
 201
 202 BT_HIDDEN
 203 void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
 204                 struct metadata_context *context)
 205 {
 206         uint8_t *uuid;
 207
 208         BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
 209                 "name=\"%s\", metadata-context-addr=%p", clock_class,
 210                 bt_ctf_clock_class_get_name(clock_class),
 211                 context);
 212
 213         if (!clock_class || !context) {
 214                 BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
 215                         "clock-class-addr=%p, name=\"%s\", metadata-context-addr=%p",
 216                         clock_class,
 217                         bt_ctf_clock_class_get_name(clock_class),
 218                         context);
 219                 return;
 220         }
 221
 222         uuid = clock_class->uuid;
 223         g_string_append(context->string, "clock {\n");
 224         g_string_append_printf(context->string, "\tname = %s;\n",
 225                 clock_class->name->str);
 226
 227         if (clock_class->uuid_set) {
 228                 g_string_append_printf(context->string,
 229                         "\tuuid = \"" BT_UUID_FMT "\";\n",
 230                         BT_UUID_FMT_VALUES(uuid));
 231         }
 232
 233         if (clock_class->description) {
 234                 g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
 235                         clock_class->description->str);
 236         }
 237
 238         g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
 239                 clock_class->frequency);
 240         g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
 241                 clock_class->precision);
 242         g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
 243                 clock_class->offset_s);
 244         g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
 245                 clock_class->offset);
 246         g_string_append_printf(context->string, "\tabsolute = %s;\n",
 247                 clock_class->absolute ? "true" : "false");
 248         g_string_append(context->string, "};\n\n");
 249 }