src/ctf-writer/clock.c

   1 /*
   2  * clock.c
   3  *
   4  * Babeltrace CTF writer - Clock
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
   8  *
   9  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30 #define BT_LOG_TAG "CTF-WRITER/CLOCK"
  31 #include "logging.h"
  32
  33 #include "common/assert.h"
  34 #include "compat/uuid.h"
  35 #include "compat/compiler.h"
  36 #include <babeltrace2/ctf-writer/utils.h>
  37 #include <babeltrace2/ctf-writer/object.h>
  38 #include <inttypes.h>
  39
  40 #include "clock-class.h"
  41 #include "clock.h"
  42 #include "object.h"
  43 #include "writer.h"
  44
  45 static
  46 void bt_ctf_clock_destroy(struct bt_ctf_object *obj);
  47
  48 struct bt_ctf_clock *bt_ctf_clock_create(const char *name)
  49 {
  50         int ret;
  51         struct bt_ctf_clock *clock = NULL;
  52         unsigned char cc_uuid[BABELTRACE_UUID_LEN];
  53
  54         BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
  55         clock = g_new0(struct bt_ctf_clock, 1);
  56         if (!clock) {
  57                 goto error;
  58         }
  59
  60         bt_ctf_object_init_shared(&clock->base, bt_ctf_clock_destroy);
  61         clock->value = 0;
  62
  63         /* Pre-2.0.0 backward compatibility: default frequency is 1 GHz */
  64         clock->clock_class = (void *) bt_ctf_clock_class_create(name, 1000000000);
  65         if (!clock->clock_class) {
  66                 goto error;
  67         }
  68
  69         /* Automatically set clock class's UUID. */
  70         ret = bt_uuid_generate(cc_uuid);
  71         if (ret) {
  72                 goto error;
  73         }
  74
  75         ret = bt_ctf_clock_class_set_uuid(clock->clock_class, cc_uuid);
  76         BT_ASSERT(ret == 0);
  77         return clock;
  78
  79 error:
  80         BT_CTF_OBJECT_PUT_REF_AND_RESET(clock);
  81         return clock;
  82 }
  83
  84 const char *bt_ctf_clock_get_name(struct bt_ctf_clock *clock)
  85 {
  86         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  87         return bt_ctf_clock_class_get_name(clock->clock_class);
  88 }
  89
  90 const char *bt_ctf_clock_get_description(struct bt_ctf_clock *clock)
  91 {
  92         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  93         return bt_ctf_clock_class_get_description(clock->clock_class);
  94 }
  95
  96 int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc)
  97 {
  98         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
  99         return bt_ctf_clock_class_set_description(clock->clock_class,
 100                 desc);
 101 }
 102
 103 uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock)
 104 {
 105         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 106         return bt_ctf_clock_class_get_frequency(clock->clock_class);
 107 }
 108
 109 int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq)
 110 {
 111         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 112         return bt_ctf_clock_class_set_frequency(clock->clock_class,
 113                 freq);
 114 }
 115
 116 uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock)
 117 {
 118         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 119         return bt_ctf_clock_class_get_precision(clock->clock_class);
 120 }
 121
 122 int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision)
 123 {
 124         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 125         return bt_ctf_clock_class_set_precision(clock->clock_class,
 126                 precision);
 127 }
 128
 129 int bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock, int64_t *offset_s)
 130 {
 131         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 132         return bt_ctf_clock_class_get_offset_s(clock->clock_class,
 133                 offset_s);
 134 }
 135
 136 int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, int64_t offset_s)
 137 {
 138         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 139         return bt_ctf_clock_class_set_offset_s(clock->clock_class,
 140                 offset_s);
 141 }
 142
 143 int bt_ctf_clock_get_offset(struct bt_ctf_clock *clock, int64_t *offset)
 144 {
 145         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 146         return bt_ctf_clock_class_get_offset_cycles(clock->clock_class,
 147                 offset);
 148 }
 149
 150 int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, int64_t offset)
 151 {
 152         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 153         return bt_ctf_clock_class_set_offset_cycles(clock->clock_class,
 154                 offset);
 155 }
 156
 157 int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock)
 158 {
 159         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 160         return bt_ctf_clock_class_is_absolute(clock->clock_class);
 161 }
 162
 163 int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute)
 164 {
 165         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 166         return bt_ctf_clock_class_set_is_absolute(clock->clock_class,
 167                 is_absolute);
 168 }
 169
 170 const unsigned char *bt_ctf_clock_get_uuid(struct bt_ctf_clock *clock)
 171 {
 172         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 173         return bt_ctf_clock_class_get_uuid(clock->clock_class);
 174 }
 175
 176 int bt_ctf_clock_set_uuid(struct bt_ctf_clock *clock, const unsigned char *uuid)
 177 {
 178         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 179         return bt_ctf_clock_class_set_uuid(clock->clock_class, uuid);
 180 }
 181
 182 int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, int64_t time)
 183 {
 184         int64_t value;
 185         struct bt_ctf_clock_class *cc;
 186
 187         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 188         cc = clock->clock_class;
 189
 190         /* Common case where cycles are actually nanoseconds */
 191         if (cc->frequency == 1000000000) {
 192                 value = time;
 193         } else {
 194                 value = (uint64_t) (((double) time *
 195                         (double) cc->frequency) / 1e9);
 196         }
 197
 198         BT_CTF_ASSERT_PRE(clock->value <= value,
 199                 "CTF writer clock value must be updated monotonically: "
 200                 "prev-value=%" PRId64 ", new-value=%" PRId64,
 201                 clock->value, value);
 202         clock->value = value;
 203         return 0;
 204 }
 205
 206 BT_HIDDEN
 207 int bt_ctf_clock_get_value(struct bt_ctf_clock *clock, uint64_t *value)
 208 {
 209         BT_CTF_ASSERT_PRE_NON_NULL(clock, "CTF writer clock");
 210         BT_CTF_ASSERT_PRE_NON_NULL(value, "Value");
 211         *value = clock->value;
 212         return 0;
 213 }
 214
 215 static
 216 void bt_ctf_clock_destroy(struct bt_ctf_object *obj)
 217 {
 218         struct bt_ctf_clock *clock;
 219
 220         clock = container_of(obj, struct bt_ctf_clock, base);
 221         bt_ctf_object_put_ref(clock->clock_class);
 222         g_free(clock);
 223 }
 224
 225 BT_HIDDEN
 226 void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
 227                 struct metadata_context *context)
 228 {
 229         unsigned char *uuid;
 230
 231         BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
 232                 "name=\"%s\", metadata-context-addr=%p", clock_class,
 233                 bt_ctf_clock_class_get_name(clock_class),
 234                 context);
 235
 236         if (!clock_class || !context) {
 237                 BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
 238                         "clock-class-addr=%p, name=\"%s\", metadata-context-addr=%p",
 239                         clock_class,
 240                         bt_ctf_clock_class_get_name(clock_class),
 241                         context);
 242                 return;
 243         }
 244
 245         uuid = clock_class->uuid;
 246         g_string_append(context->string, "clock {\n");
 247         g_string_append_printf(context->string, "\tname = %s;\n",
 248                 clock_class->name->str);
 249
 250         if (clock_class->uuid_set) {
 251                 g_string_append_printf(context->string,
 252                         "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 253                         uuid[0], uuid[1], uuid[2], uuid[3],
 254                         uuid[4], uuid[5], uuid[6], uuid[7],
 255                         uuid[8], uuid[9], uuid[10], uuid[11],
 256                         uuid[12], uuid[13], uuid[14], uuid[15]);
 257         }
 258
 259         if (clock_class->description) {
 260                 g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
 261                         clock_class->description->str);
 262         }
 263
 264         g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
 265                 clock_class->frequency);
 266         g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
 267                 clock_class->precision);
 268         g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
 269                 clock_class->offset_s);
 270         g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
 271                 clock_class->offset);
 272         g_string_append_printf(context->string, "\tabsolute = %s;\n",
 273                 clock_class->absolute ? "true" : "false");
 274         g_string_append(context->string, "};\n\n");
 275 }