lib/ctf-ir/clock-class.c

   1 /*
   2  * clock-class.c
   3  *
   4  * Babeltrace CTF IR - Clock class
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #define BT_LOG_TAG "CLOCK-CLASS"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/ctf-ir/clock-class-internal.h>
  33 #include <babeltrace/ctf-ir/utils.h>
  34 #include <babeltrace/ref.h>
  35 #include <babeltrace/compiler-internal.h>
  36 #include <babeltrace/types.h>
  37 #include <inttypes.h>
  38 #include <babeltrace/object-internal.h>
  39
  40 static
  41 void bt_ctf_clock_class_destroy(struct bt_object *obj);
  42
  43 BT_HIDDEN
  44 bt_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
  45 {
  46         return clock_class && clock_class->name;
  47 }
  48
  49 int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class,
  50                 const char *name)
  51 {
  52         int ret = 0;
  53
  54         if (!clock_class) {
  55                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
  56                 ret = -1;
  57                 goto end;
  58         }
  59
  60         if (clock_class->frozen) {
  61                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
  62                         clock_class, bt_ctf_clock_class_get_name(clock_class));
  63                 ret = -1;
  64                 goto end;
  65         }
  66
  67         if (bt_ctf_validate_identifier(name)) {
  68                 BT_LOGE("Clock class's name is not a valid CTF identifier: "
  69                         "addr=%p, name=\"%s\"",
  70                         clock_class, name);
  71                 ret = -1;
  72                 goto end;
  73         }
  74
  75         if (clock_class->name) {
  76                 g_string_assign(clock_class->name, name);
  77         } else {
  78                 clock_class->name = g_string_new(name);
  79                 if (!clock_class->name) {
  80                         BT_LOGE_STR("Failed to allocate a GString.");
  81                         ret = -1;
  82                         goto end;
  83                 }
  84         }
  85
  86         BT_LOGV("Set clock class's name: addr=%p, name=\"%s\"",
  87                 clock_class, name);
  88
  89 end:
  90         return ret;
  91 }
  92
  93 struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name)
  94 {
  95         int ret;
  96         struct bt_ctf_clock_class *clock_class;
  97
  98         BT_LOGD("Creating default clock class object: name=\"%s\"",
  99                 name);
 100         clock_class = g_new0(struct bt_ctf_clock_class, 1);
 101         if (!clock_class) {
 102                 BT_LOGE_STR("Failed to allocate one clock class.");
 103                 goto error;
 104         }
 105
 106         clock_class->precision = 1;
 107         clock_class->frequency = 1000000000;
 108         bt_object_init(clock_class, bt_ctf_clock_class_destroy);
 109
 110         if (name) {
 111                 ret = bt_ctf_clock_class_set_name(clock_class, name);
 112                 if (ret) {
 113                         BT_LOGE("Cannot set clock class's name: "
 114                                 "addr=%p, name=\"%s\"",
 115                                 clock_class, name);
 116                         goto error;
 117                 }
 118         }
 119
 120         ret = bt_uuid_generate(clock_class->uuid);
 121         if (ret) {
 122                 BT_LOGE_STR("Failed to generate a UUID.");
 123                 goto error;
 124         }
 125
 126         clock_class->uuid_set = 1;
 127         BT_LOGD("Created clock class object: addr=%p, name=\"%s\"",
 128                 clock_class, name);
 129         return clock_class;
 130 error:
 131         BT_PUT(clock_class);
 132         return clock_class;
 133 }
 134
 135 const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class)
 136 {
 137         const char *ret = NULL;
 138
 139         if (!clock_class) {
 140                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 141                 goto end;
 142         }
 143
 144         if (clock_class->name) {
 145                 ret = clock_class->name->str;
 146         }
 147
 148 end:
 149         return ret;
 150 }
 151
 152 const char *bt_ctf_clock_class_get_description(
 153                 struct bt_ctf_clock_class *clock_class)
 154 {
 155         const char *ret = NULL;
 156
 157         if (!clock_class) {
 158                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 159                 goto end;
 160         }
 161
 162         if (clock_class->description) {
 163                 ret = clock_class->description->str;
 164         }
 165 end:
 166         return ret;
 167 }
 168
 169 int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
 170                 const char *desc)
 171 {
 172         int ret = 0;
 173
 174         if (!clock_class || !desc) {
 175                 BT_LOGW("Invalid parameter: clock class or description is NULL: "
 176                         "clock-class-addr=%p, name=\"%s\", desc-addr=%p",
 177                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 178                         desc);
 179                 ret = -1;
 180                 goto end;
 181         }
 182
 183         if (clock_class->frozen) {
 184                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 185                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 186                 ret = -1;
 187                 goto end;
 188         }
 189
 190         clock_class->description = g_string_new(desc);
 191         ret = clock_class->description ? 0 : -1;
 192         BT_LOGV("Set clock class's description: addr=%p, "
 193                 "name=\"%s\", desc=\"%s\"",
 194                 clock_class, bt_ctf_clock_class_get_name(clock_class), desc);
 195 end:
 196         return ret;
 197 }
 198
 199 uint64_t bt_ctf_clock_class_get_frequency(
 200                 struct bt_ctf_clock_class *clock_class)
 201 {
 202         uint64_t ret = -1ULL;
 203
 204         if (!clock_class) {
 205                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 206                 goto end;
 207         }
 208
 209         ret = clock_class->frequency;
 210 end:
 211         return ret;
 212 }
 213
 214 int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
 215                 uint64_t freq)
 216 {
 217         int ret = 0;
 218
 219         if (!clock_class || freq == -1ULL) {
 220                 BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
 221                         "addr=%p, name=\"%s\", freq=%" PRIu64,
 222                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 223                         freq);
 224                 ret = -1;
 225                 goto end;
 226         }
 227
 228         if (clock_class->frozen) {
 229                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 230                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 231                 ret = -1;
 232                 goto end;
 233         }
 234
 235         clock_class->frequency = freq;
 236         BT_LOGV("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64,
 237                 clock_class, bt_ctf_clock_class_get_name(clock_class), freq);
 238 end:
 239         return ret;
 240 }
 241
 242 uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
 243 {
 244         uint64_t ret = -1ULL;
 245
 246         if (!clock_class) {
 247                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 248                 goto end;
 249         }
 250
 251         ret = clock_class->precision;
 252 end:
 253         return ret;
 254 }
 255
 256 int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
 257                 uint64_t precision)
 258 {
 259         int ret = 0;
 260
 261         if (!clock_class || precision == -1ULL) {
 262                 BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
 263                         "addr=%p, name=\"%s\", precision=%" PRIu64,
 264                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 265                         precision);
 266                 ret = -1;
 267                 goto end;
 268         }
 269
 270         if (clock_class->frozen) {
 271                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 272                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 273                 ret = -1;
 274                 goto end;
 275         }
 276
 277         clock_class->precision = precision;
 278         BT_LOGV("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64,
 279                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 280                 precision);
 281 end:
 282         return ret;
 283 }
 284
 285 int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
 286                 int64_t *offset_s)
 287 {
 288         int ret = 0;
 289
 290         if (!clock_class || !offset_s) {
 291                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 292                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 293                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 294                         offset_s);
 295                 ret = -1;
 296                 goto end;
 297         }
 298
 299         *offset_s = clock_class->offset_s;
 300 end:
 301         return ret;
 302 }
 303
 304 int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
 305                 int64_t offset_s)
 306 {
 307         int ret = 0;
 308
 309         if (!clock_class) {
 310                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 311                 ret = -1;
 312                 goto end;
 313         }
 314
 315         if (clock_class->frozen) {
 316                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 317                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 318                 ret = -1;
 319                 goto end;
 320         }
 321
 322         clock_class->offset_s = offset_s;
 323         BT_LOGV("Set clock class's offset (seconds): "
 324                 "addr=%p, name=\"%s\", offset-s=%" PRId64,
 325                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 326                 offset_s);
 327 end:
 328         return ret;
 329 }
 330
 331 int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
 332                 int64_t *offset)
 333 {
 334         int ret = 0;
 335
 336         if (!clock_class || !offset) {
 337                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 338                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 339                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 340                         offset);
 341                 ret = -1;
 342                 goto end;
 343         }
 344
 345         *offset = clock_class->offset;
 346 end:
 347         return ret;
 348 }
 349
 350 int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
 351                 int64_t offset)
 352 {
 353         int ret = 0;
 354
 355         if (!clock_class) {
 356                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 357                 ret = -1;
 358                 goto end;
 359         }
 360
 361         if (clock_class->frozen) {
 362                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 363                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 364                 ret = -1;
 365                 goto end;
 366         }
 367
 368         clock_class->offset = offset;
 369         BT_LOGV("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64,
 370                 clock_class, bt_ctf_clock_class_get_name(clock_class), offset);
 371 end:
 372         return ret;
 373 }
 374
 375 bt_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
 376 {
 377         int ret = -1;
 378
 379         if (!clock_class) {
 380                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 381                 goto end;
 382         }
 383
 384         ret = clock_class->absolute;
 385 end:
 386         return ret;
 387 }
 388
 389 int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
 390                 bt_bool is_absolute)
 391 {
 392         int ret = 0;
 393
 394         if (!clock_class) {
 395                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 396                 ret = -1;
 397                 goto end;
 398         }
 399
 400         if (clock_class->frozen) {
 401                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 402                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 403                 ret = -1;
 404                 goto end;
 405         }
 406
 407         clock_class->absolute = !!is_absolute;
 408         BT_LOGV("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d",
 409                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 410                 is_absolute);
 411 end:
 412         return ret;
 413 }
 414
 415 const unsigned char *bt_ctf_clock_class_get_uuid(
 416                 struct bt_ctf_clock_class *clock_class)
 417 {
 418         const unsigned char *ret;
 419
 420         if (!clock_class) {
 421                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 422                 ret = NULL;
 423                 goto end;
 424         }
 425
 426         if (!clock_class->uuid_set) {
 427                 BT_LOGV("Clock class's UUID is not set: addr=%p, name=\"%s\"",
 428                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 429                 ret = NULL;
 430                 goto end;
 431         }
 432
 433         ret = clock_class->uuid;
 434 end:
 435         return ret;
 436 }
 437
 438 int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
 439                 const unsigned char *uuid)
 440 {
 441         int ret = 0;
 442
 443         if (!clock_class || !uuid) {
 444                 BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
 445                         "clock-class-addr=%p, name=\"%s\", uuid-addr=%p",
 446                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 447                         uuid);
 448                 ret = -1;
 449                 goto end;
 450         }
 451
 452         if (clock_class->frozen) {
 453                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 454                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 455                 ret = -1;
 456                 goto end;
 457         }
 458
 459         memcpy(clock_class->uuid, uuid, sizeof(uuid_t));
 460         clock_class->uuid_set = 1;
 461         BT_LOGV("Set clock class's UUID: addr=%p, name=\"%s\", "
 462                 "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 463                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 464                 (unsigned int) uuid[0],
 465                 (unsigned int) uuid[1],
 466                 (unsigned int) uuid[2],
 467                 (unsigned int) uuid[3],
 468                 (unsigned int) uuid[4],
 469                 (unsigned int) uuid[5],
 470                 (unsigned int) uuid[6],
 471                 (unsigned int) uuid[7],
 472                 (unsigned int) uuid[8],
 473                 (unsigned int) uuid[9],
 474                 (unsigned int) uuid[10],
 475                 (unsigned int) uuid[11],
 476                 (unsigned int) uuid[12],
 477                 (unsigned int) uuid[13],
 478                 (unsigned int) uuid[14],
 479                 (unsigned int) uuid[15]);
 480 end:
 481         return ret;
 482 }
 483
 484 static uint64_t ns_from_value(uint64_t frequency, uint64_t value)
 485 {
 486         uint64_t ns;
 487
 488         if (frequency == 1000000000) {
 489                 ns = value;
 490         } else {
 491                 ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
 492         }
 493
 494         return ns;
 495 }
 496
 497 BT_HIDDEN
 498 void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
 499 {
 500         if (!clock_class) {
 501                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 502                 return;
 503         }
 504
 505         if (!clock_class->frozen) {
 506                 BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"",
 507                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 508                 clock_class->frozen = 1;
 509         }
 510 }
 511
 512 BT_HIDDEN
 513 void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
 514                 struct metadata_context *context)
 515 {
 516         unsigned char *uuid;
 517
 518         BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
 519                 "name=\"%s\", metadata-context-addr=%p", clock_class,
 520                 bt_ctf_clock_class_get_name(clock_class), context);
 521
 522         if (!clock_class || !context) {
 523                 BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
 524                         "clock-class-addr=%p, name=\"%s\", metadata-context-addr=%p",
 525                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 526                         context);
 527                 return;
 528         }
 529
 530         uuid = clock_class->uuid;
 531         g_string_append(context->string, "clock {\n");
 532         g_string_append_printf(context->string, "\tname = %s;\n",
 533                 clock_class->name->str);
 534         g_string_append_printf(context->string,
 535                 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 536                 uuid[0], uuid[1], uuid[2], uuid[3],
 537                 uuid[4], uuid[5], uuid[6], uuid[7],
 538                 uuid[8], uuid[9], uuid[10], uuid[11],
 539                 uuid[12], uuid[13], uuid[14], uuid[15]);
 540         if (clock_class->description) {
 541                 g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
 542                         clock_class->description->str);
 543         }
 544
 545         g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
 546                 clock_class->frequency);
 547         g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
 548                 clock_class->precision);
 549         g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
 550                 clock_class->offset_s);
 551         g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
 552                 clock_class->offset);
 553         g_string_append_printf(context->string, "\tabsolute = %s;\n",
 554                 clock_class->absolute ? "TRUE" : "FALSE");
 555         g_string_append(context->string, "};\n\n");
 556 }
 557
 558 static
 559 void bt_ctf_clock_class_destroy(struct bt_object *obj)
 560 {
 561         struct bt_ctf_clock_class *clock_class;
 562
 563         clock_class = container_of(obj, struct bt_ctf_clock_class, base);
 564         BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"",
 565                 obj, bt_ctf_clock_class_get_name(clock_class));
 566         if (clock_class->name) {
 567                 g_string_free(clock_class->name, TRUE);
 568         }
 569         if (clock_class->description) {
 570                 g_string_free(clock_class->description, TRUE);
 571         }
 572
 573         g_free(clock_class);
 574 }
 575
 576 static
 577 void bt_ctf_clock_value_destroy(struct bt_object *obj)
 578 {
 579         struct bt_ctf_clock_value *value;
 580
 581         if (!obj) {
 582                 return;
 583         }
 584
 585         value = container_of(obj, struct bt_ctf_clock_value, base);
 586         BT_LOGD("Destroying clock value: addr=%p, clock-class-addr=%p, "
 587                 "clock-class-name=\"%s\"", obj, value->clock_class,
 588                 bt_ctf_clock_class_get_name(value->clock_class));
 589         bt_put(value->clock_class);
 590         g_free(value);
 591 }
 592
 593 struct bt_ctf_clock_value *bt_ctf_clock_value_create(
 594                 struct bt_ctf_clock_class *clock_class, uint64_t value)
 595 {
 596         struct bt_ctf_clock_value *ret = NULL;
 597
 598         BT_LOGD("Creating clock value object: clock-class-addr=%p, "
 599                 "clock-class-name=\"%s\", value=%" PRIu64, clock_class,
 600                 bt_ctf_clock_class_get_name(clock_class), value);
 601
 602         if (!clock_class) {
 603                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 604                 goto end;
 605         }
 606
 607         ret = g_new0(struct bt_ctf_clock_value, 1);
 608         if (!ret) {
 609                 BT_LOGE_STR("Failed to allocate one clock value.");
 610                 goto end;
 611         }
 612
 613         bt_object_init(ret, bt_ctf_clock_value_destroy);
 614         ret->clock_class = bt_get(clock_class);
 615         ret->value = value;
 616         BT_LOGD("Created clock value object: clock-value-addr=%p, "
 617                 "clock-class-addr=%p, clock-class-name=\"%s\"",
 618                 ret, clock_class, bt_ctf_clock_class_get_name(clock_class));
 619 end:
 620         return ret;
 621 }
 622
 623 int bt_ctf_clock_value_get_value(
 624                 struct bt_ctf_clock_value *clock_value, uint64_t *raw_value)
 625 {
 626         int ret = 0;
 627
 628         if (!clock_value || !raw_value) {
 629                 BT_LOGW("Invalid parameter: clock value or raw value is NULL: "
 630                         "clock-value-addr=%p, raw-value-addr=%p",
 631                         clock_value, raw_value);
 632                 ret = -1;
 633                 goto end;
 634         }
 635
 636         *raw_value = clock_value->value;
 637 end:
 638         return ret;
 639 }
 640
 641 int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
 642                 int64_t *ret_value_ns)
 643 {
 644         int ret = 0;
 645         int64_t ns;
 646
 647         if (!value || !ret_value_ns) {
 648                 BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: "
 649                         "clock-value-addr=%p, ret-value-addr=%p",
 650                         value, ret_value_ns);
 651                 ret = -1;
 652                 goto end;
 653         }
 654
 655         /* Initialize nanosecond timestamp to clock's offset in seconds. */
 656         ns = value->clock_class->offset_s * (int64_t) 1000000000;
 657
 658         /* Add offset in cycles, converted to nanoseconds. */
 659         ns += ns_from_value(value->clock_class->frequency,
 660                         value->clock_class->offset);
 661
 662         /* Add given value, converter to nanoseconds. */
 663         ns += ns_from_value(value->clock_class->frequency, value->value);
 664
 665         *ret_value_ns = ns;
 666 end:
 667         return ret;
 668 }
 669
 670 struct bt_ctf_clock_class *bt_ctf_clock_value_get_class(
 671                 struct bt_ctf_clock_value *clock_value)
 672 {
 673         struct bt_ctf_clock_class *clock_class = NULL;
 674
 675         if (!clock_value) {
 676                 BT_LOGW_STR("Invalid parameter: clock value is NULL.");
 677                 goto end;
 678         }
 679
 680         clock_class = bt_get(clock_value->clock_class);
 681
 682 end:
 683         return clock_class;
 684 }