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/compat/uuid-internal.h>
  33 #include <babeltrace/ctf-ir/clock-class-internal.h>
  34 #include <babeltrace/ctf-ir/utils.h>
  35 #include <babeltrace/ref.h>
  36 #include <babeltrace/compiler-internal.h>
  37 #include <babeltrace/types.h>
  38 #include <babeltrace/compat/string-internal.h>
  39 #include <inttypes.h>
  40 #include <babeltrace/object-internal.h>
  41
  42 static
  43 void bt_ctf_clock_class_destroy(struct bt_object *obj);
  44
  45 BT_HIDDEN
  46 bt_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
  47 {
  48         return clock_class && clock_class->name;
  49 }
  50
  51 int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class,
  52                 const char *name)
  53 {
  54         int ret = 0;
  55
  56         if (!clock_class) {
  57                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
  58                 ret = -1;
  59                 goto end;
  60         }
  61
  62         if (clock_class->frozen) {
  63                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
  64                         clock_class, bt_ctf_clock_class_get_name(clock_class));
  65                 ret = -1;
  66                 goto end;
  67         }
  68
  69         if (bt_ctf_validate_identifier(name)) {
  70                 BT_LOGE("Clock class's name is not a valid CTF identifier: "
  71                         "addr=%p, name=\"%s\"",
  72                         clock_class, name);
  73                 ret = -1;
  74                 goto end;
  75         }
  76
  77         if (clock_class->name) {
  78                 g_string_assign(clock_class->name, name);
  79         } else {
  80                 clock_class->name = g_string_new(name);
  81                 if (!clock_class->name) {
  82                         BT_LOGE_STR("Failed to allocate a GString.");
  83                         ret = -1;
  84                         goto end;
  85                 }
  86         }
  87
  88         BT_LOGV("Set clock class's name: addr=%p, name=\"%s\"",
  89                 clock_class, name);
  90
  91 end:
  92         return ret;
  93 }
  94
  95 static
  96 bool validate_freq(struct bt_ctf_clock_class *clock_class,
  97                 const char *name, uint64_t freq)
  98 {
  99         bool is_valid = true;
 100
 101         if (freq == -1ULL || freq == 0) {
 102                 BT_LOGW("Invalid parameter: frequency is invalid: "
 103                         "addr=%p, name=\"%s\", freq=%" PRIu64,
 104                         clock_class, name, freq);
 105                 is_valid = false;
 106                 goto end;
 107         }
 108
 109 end:
 110         return is_valid;
 111 }
 112
 113 struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name,
 114                 uint64_t freq)
 115 {
 116         int ret;
 117         struct bt_ctf_clock_class *clock_class = NULL;
 118
 119         BT_LOGD("Creating default clock class object: name=\"%s\"",
 120                 name);
 121
 122         if (!validate_freq(NULL, name, freq)) {
 123                 /* validate_freq() logs errors */
 124                 goto error;
 125         }
 126
 127         clock_class = g_new0(struct bt_ctf_clock_class, 1);
 128         if (!clock_class) {
 129                 BT_LOGE_STR("Failed to allocate one clock class.");
 130                 goto error;
 131         }
 132
 133         clock_class->precision = 1;
 134         clock_class->frequency = freq;
 135         bt_object_init(clock_class, bt_ctf_clock_class_destroy);
 136
 137         if (name) {
 138                 ret = bt_ctf_clock_class_set_name(clock_class, name);
 139                 if (ret) {
 140                         BT_LOGE("Cannot set clock class's name: "
 141                                 "addr=%p, name=\"%s\"",
 142                                 clock_class, name);
 143                         goto error;
 144                 }
 145         }
 146
 147         BT_LOGD("Created clock class object: addr=%p, name=\"%s\"",
 148                 clock_class, name);
 149         return clock_class;
 150 error:
 151         BT_PUT(clock_class);
 152         return clock_class;
 153 }
 154
 155 const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class)
 156 {
 157         const char *ret = NULL;
 158
 159         if (!clock_class) {
 160                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 161                 goto end;
 162         }
 163
 164         if (clock_class->name) {
 165                 ret = clock_class->name->str;
 166         }
 167
 168 end:
 169         return ret;
 170 }
 171
 172 const char *bt_ctf_clock_class_get_description(
 173                 struct bt_ctf_clock_class *clock_class)
 174 {
 175         const char *ret = NULL;
 176
 177         if (!clock_class) {
 178                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 179                 goto end;
 180         }
 181
 182         if (clock_class->description) {
 183                 ret = clock_class->description->str;
 184         }
 185 end:
 186         return ret;
 187 }
 188
 189 int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
 190                 const char *desc)
 191 {
 192         int ret = 0;
 193
 194         if (!clock_class || !desc) {
 195                 BT_LOGW("Invalid parameter: clock class or description is NULL: "
 196                         "clock-class-addr=%p, name=\"%s\", desc-addr=%p",
 197                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 198                         desc);
 199                 ret = -1;
 200                 goto end;
 201         }
 202
 203         if (clock_class->frozen) {
 204                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 205                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 206                 ret = -1;
 207                 goto end;
 208         }
 209
 210         clock_class->description = g_string_new(desc);
 211         ret = clock_class->description ? 0 : -1;
 212         BT_LOGV("Set clock class's description: addr=%p, "
 213                 "name=\"%s\", desc=\"%s\"",
 214                 clock_class, bt_ctf_clock_class_get_name(clock_class), desc);
 215 end:
 216         return ret;
 217 }
 218
 219 uint64_t bt_ctf_clock_class_get_frequency(
 220                 struct bt_ctf_clock_class *clock_class)
 221 {
 222         uint64_t ret = -1ULL;
 223
 224         if (!clock_class) {
 225                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 226                 goto end;
 227         }
 228
 229         ret = clock_class->frequency;
 230 end:
 231         return ret;
 232 }
 233
 234 int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
 235                 uint64_t freq)
 236 {
 237         int ret = 0;
 238
 239         if (!clock_class) {
 240                 BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
 241                         "addr=%p, name=\"%s\"",
 242                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 243                 ret = -1;
 244                 goto end;
 245         }
 246
 247         if (!validate_freq(clock_class, bt_ctf_clock_class_get_name(clock_class),
 248                         freq)) {
 249                 /* validate_freq() logs errors */
 250                 goto end;
 251         }
 252
 253         if (clock_class->frozen) {
 254                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 255                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 256                 ret = -1;
 257                 goto end;
 258         }
 259
 260         clock_class->frequency = freq;
 261         BT_LOGV("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64,
 262                 clock_class, bt_ctf_clock_class_get_name(clock_class), freq);
 263 end:
 264         return ret;
 265 }
 266
 267 uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
 268 {
 269         uint64_t ret = -1ULL;
 270
 271         if (!clock_class) {
 272                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 273                 goto end;
 274         }
 275
 276         ret = clock_class->precision;
 277 end:
 278         return ret;
 279 }
 280
 281 int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
 282                 uint64_t precision)
 283 {
 284         int ret = 0;
 285
 286         if (!clock_class || precision == -1ULL) {
 287                 BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
 288                         "addr=%p, name=\"%s\", precision=%" PRIu64,
 289                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 290                         precision);
 291                 ret = -1;
 292                 goto end;
 293         }
 294
 295         if (clock_class->frozen) {
 296                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 297                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 298                 ret = -1;
 299                 goto end;
 300         }
 301
 302         clock_class->precision = precision;
 303         BT_LOGV("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64,
 304                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 305                 precision);
 306 end:
 307         return ret;
 308 }
 309
 310 int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
 311                 int64_t *offset_s)
 312 {
 313         int ret = 0;
 314
 315         if (!clock_class || !offset_s) {
 316                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 317                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 318                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 319                         offset_s);
 320                 ret = -1;
 321                 goto end;
 322         }
 323
 324         *offset_s = clock_class->offset_s;
 325 end:
 326         return ret;
 327 }
 328
 329 int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
 330                 int64_t offset_s)
 331 {
 332         int ret = 0;
 333
 334         if (!clock_class) {
 335                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 336                 ret = -1;
 337                 goto end;
 338         }
 339
 340         if (clock_class->frozen) {
 341                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 342                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 343                 ret = -1;
 344                 goto end;
 345         }
 346
 347         clock_class->offset_s = offset_s;
 348         BT_LOGV("Set clock class's offset (seconds): "
 349                 "addr=%p, name=\"%s\", offset-s=%" PRId64,
 350                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 351                 offset_s);
 352 end:
 353         return ret;
 354 }
 355
 356 int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
 357                 int64_t *offset)
 358 {
 359         int ret = 0;
 360
 361         if (!clock_class || !offset) {
 362                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 363                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 364                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 365                         offset);
 366                 ret = -1;
 367                 goto end;
 368         }
 369
 370         *offset = clock_class->offset;
 371 end:
 372         return ret;
 373 }
 374
 375 int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
 376                 int64_t offset)
 377 {
 378         int ret = 0;
 379
 380         if (!clock_class) {
 381                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 382                 ret = -1;
 383                 goto end;
 384         }
 385
 386         if (clock_class->frozen) {
 387                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 388                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 389                 ret = -1;
 390                 goto end;
 391         }
 392
 393         clock_class->offset = offset;
 394         BT_LOGV("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64,
 395                 clock_class, bt_ctf_clock_class_get_name(clock_class), offset);
 396 end:
 397         return ret;
 398 }
 399
 400 bt_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
 401 {
 402         int ret = -1;
 403
 404         if (!clock_class) {
 405                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 406                 goto end;
 407         }
 408
 409         ret = clock_class->absolute;
 410 end:
 411         return ret;
 412 }
 413
 414 int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
 415                 bt_bool is_absolute)
 416 {
 417         int ret = 0;
 418
 419         if (!clock_class) {
 420                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 421                 ret = -1;
 422                 goto end;
 423         }
 424
 425         if (clock_class->frozen) {
 426                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 427                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 428                 ret = -1;
 429                 goto end;
 430         }
 431
 432         clock_class->absolute = !!is_absolute;
 433         BT_LOGV("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d",
 434                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 435                 is_absolute);
 436 end:
 437         return ret;
 438 }
 439
 440 const unsigned char *bt_ctf_clock_class_get_uuid(
 441                 struct bt_ctf_clock_class *clock_class)
 442 {
 443         const unsigned char *ret;
 444
 445         if (!clock_class) {
 446                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 447                 ret = NULL;
 448                 goto end;
 449         }
 450
 451         if (!clock_class->uuid_set) {
 452                 BT_LOGV("Clock class's UUID is not set: addr=%p, name=\"%s\"",
 453                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 454                 ret = NULL;
 455                 goto end;
 456         }
 457
 458         ret = clock_class->uuid;
 459 end:
 460         return ret;
 461 }
 462
 463 int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
 464                 const unsigned char *uuid)
 465 {
 466         int ret = 0;
 467
 468         if (!clock_class || !uuid) {
 469                 BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
 470                         "clock-class-addr=%p, name=\"%s\", uuid-addr=%p",
 471                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 472                         uuid);
 473                 ret = -1;
 474                 goto end;
 475         }
 476
 477         if (clock_class->frozen) {
 478                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 479                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 480                 ret = -1;
 481                 goto end;
 482         }
 483
 484         memcpy(clock_class->uuid, uuid, BABELTRACE_UUID_LEN);
 485         clock_class->uuid_set = 1;
 486         BT_LOGV("Set clock class's UUID: addr=%p, name=\"%s\", "
 487                 "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 488                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 489                 (unsigned int) uuid[0],
 490                 (unsigned int) uuid[1],
 491                 (unsigned int) uuid[2],
 492                 (unsigned int) uuid[3],
 493                 (unsigned int) uuid[4],
 494                 (unsigned int) uuid[5],
 495                 (unsigned int) uuid[6],
 496                 (unsigned int) uuid[7],
 497                 (unsigned int) uuid[8],
 498                 (unsigned int) uuid[9],
 499                 (unsigned int) uuid[10],
 500                 (unsigned int) uuid[11],
 501                 (unsigned int) uuid[12],
 502                 (unsigned int) uuid[13],
 503                 (unsigned int) uuid[14],
 504                 (unsigned int) uuid[15]);
 505 end:
 506         return ret;
 507 }
 508
 509 static uint64_t ns_from_value(uint64_t frequency, uint64_t value)
 510 {
 511         uint64_t ns;
 512
 513         if (frequency == 1000000000) {
 514                 ns = value;
 515         } else {
 516                 double dblres = ((1e9 * (double) value) / (double) frequency);
 517
 518                 if (dblres >= (double) UINT64_MAX) {
 519                         /* Overflows uint64_t */
 520                         ns = -1ULL;
 521                 } else {
 522                         ns = (uint64_t) dblres;
 523                 }
 524         }
 525
 526         return ns;
 527 }
 528
 529 BT_HIDDEN
 530 void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
 531 {
 532         if (!clock_class) {
 533                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 534                 return;
 535         }
 536
 537         if (!clock_class->frozen) {
 538                 BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"",
 539                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 540                 clock_class->frozen = 1;
 541         }
 542 }
 543
 544 BT_HIDDEN
 545 void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
 546                 struct metadata_context *context)
 547 {
 548         unsigned char *uuid;
 549
 550         BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
 551                 "name=\"%s\", metadata-context-addr=%p", clock_class,
 552                 bt_ctf_clock_class_get_name(clock_class), context);
 553
 554         if (!clock_class || !context) {
 555                 BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
 556                         "clock-class-addr=%p, name=\"%s\", metadata-context-addr=%p",
 557                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 558                         context);
 559                 return;
 560         }
 561
 562         uuid = clock_class->uuid;
 563         g_string_append(context->string, "clock {\n");
 564         g_string_append_printf(context->string, "\tname = %s;\n",
 565                 clock_class->name->str);
 566
 567         if (clock_class->uuid_set) {
 568                 g_string_append_printf(context->string,
 569                         "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 570                         uuid[0], uuid[1], uuid[2], uuid[3],
 571                         uuid[4], uuid[5], uuid[6], uuid[7],
 572                         uuid[8], uuid[9], uuid[10], uuid[11],
 573                         uuid[12], uuid[13], uuid[14], uuid[15]);
 574         }
 575
 576         if (clock_class->description) {
 577                 g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
 578                         clock_class->description->str);
 579         }
 580
 581         g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
 582                 clock_class->frequency);
 583         g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
 584                 clock_class->precision);
 585         g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
 586                 clock_class->offset_s);
 587         g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
 588                 clock_class->offset);
 589         g_string_append_printf(context->string, "\tabsolute = %s;\n",
 590                 clock_class->absolute ? "true" : "false");
 591         g_string_append(context->string, "};\n\n");
 592 }
 593
 594 static
 595 void bt_ctf_clock_class_destroy(struct bt_object *obj)
 596 {
 597         struct bt_ctf_clock_class *clock_class;
 598
 599         clock_class = container_of(obj, struct bt_ctf_clock_class, base);
 600         BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"",
 601                 obj, bt_ctf_clock_class_get_name(clock_class));
 602         if (clock_class->name) {
 603                 g_string_free(clock_class->name, TRUE);
 604         }
 605         if (clock_class->description) {
 606                 g_string_free(clock_class->description, TRUE);
 607         }
 608
 609         g_free(clock_class);
 610 }
 611
 612 static
 613 void bt_ctf_clock_value_destroy(struct bt_object *obj)
 614 {
 615         struct bt_ctf_clock_value *value;
 616
 617         if (!obj) {
 618                 return;
 619         }
 620
 621         value = container_of(obj, struct bt_ctf_clock_value, base);
 622         BT_LOGD("Destroying clock value: addr=%p, clock-class-addr=%p, "
 623                 "clock-class-name=\"%s\"", obj, value->clock_class,
 624                 bt_ctf_clock_class_get_name(value->clock_class));
 625         bt_put(value->clock_class);
 626         g_free(value);
 627 }
 628
 629 static
 630 void set_ns_from_epoch(struct bt_ctf_clock_value *clock_value)
 631 {
 632         struct bt_ctf_clock_class *clock_class = clock_value->clock_class;
 633         int64_t diff;
 634         int64_t s_ns;
 635         uint64_t u_ns;
 636         uint64_t cycles;
 637
 638         /* Initialize nanosecond timestamp to clock's offset in seconds */
 639         if (clock_class->offset_s <= (INT64_MIN / 1000000000) ||
 640                         clock_class->offset_s >= (INT64_MAX / 1000000000)) {
 641                 /*
 642                  * Overflow: offset in seconds converted to nanoseconds
 643                  * is outside the int64_t range.
 644                  */
 645                 clock_value->ns_from_epoch_overflows = true;
 646                 goto end;
 647         }
 648
 649         clock_value->ns_from_epoch = clock_class->offset_s * (int64_t) 1000000000;
 650
 651         /* Add offset in cycles */
 652         if (clock_class->offset < 0) {
 653                 cycles = (uint64_t) (-clock_class->offset);
 654         } else {
 655                 cycles = (uint64_t) clock_class->offset;
 656         }
 657
 658         u_ns = ns_from_value(clock_class->frequency, cycles);
 659
 660         if (u_ns == -1ULL || u_ns >= INT64_MAX) {
 661                 /*
 662                  * Overflow: offset in cycles converted to nanoseconds
 663                  * is outside the int64_t range.
 664                  */
 665                 clock_value->ns_from_epoch_overflows = true;
 666                 goto end;
 667         }
 668
 669         s_ns = (int64_t) u_ns;
 670         assert(s_ns >= 0);
 671
 672         if (clock_class->offset < 0) {
 673                 if (clock_value->ns_from_epoch >= 0) {
 674                         /*
 675                          * Offset in cycles is negative so it must also
 676                          * be negative once converted to nanoseconds.
 677                          */
 678                         s_ns = -s_ns;
 679                         goto offset_ok;
 680                 }
 681
 682                 diff = clock_value->ns_from_epoch - INT64_MIN;
 683
 684                 if (s_ns >= diff) {
 685                         /*
 686                          * Overflow: current timestamp in nanoseconds
 687                          * plus the offset in cycles converted to
 688                          * nanoseconds is outside the int64_t range.
 689                          */
 690                         clock_value->ns_from_epoch_overflows = true;
 691                         goto end;
 692                 }
 693
 694                 /*
 695                  * Offset in cycles is negative so it must also be
 696                  * negative once converted to nanoseconds.
 697                  */
 698                 s_ns = -s_ns;
 699         } else {
 700                 if (clock_value->ns_from_epoch <= 0) {
 701                         goto offset_ok;
 702                 }
 703
 704                 diff = INT64_MAX - clock_value->ns_from_epoch;
 705
 706                 if (s_ns >= diff) {
 707                         /*
 708                          * Overflow: current timestamp in nanoseconds
 709                          * plus the offset in cycles converted to
 710                          * nanoseconds is outside the int64_t range.
 711                          */
 712                         clock_value->ns_from_epoch_overflows = true;
 713                         goto end;
 714                 }
 715         }
 716
 717 offset_ok:
 718         clock_value->ns_from_epoch += s_ns;
 719
 720         /* Add clock value (cycles) */
 721         u_ns = ns_from_value(clock_class->frequency, clock_value->value);
 722
 723         if (u_ns == -1ULL || u_ns >= INT64_MAX) {
 724                 /*
 725                  * Overflow: value converted to nanoseconds is outside
 726                  * the int64_t range.
 727                  */
 728                 clock_value->ns_from_epoch_overflows = true;
 729                 goto end;
 730         }
 731
 732         s_ns = (int64_t) u_ns;
 733         assert(s_ns >= 0);
 734
 735         /* Clock value (cycles) is always positive */
 736         if (clock_value->ns_from_epoch <= 0) {
 737                 goto value_ok;
 738         }
 739
 740         diff = INT64_MAX - clock_value->ns_from_epoch;
 741
 742         if (s_ns >= diff) {
 743                 /*
 744                  * Overflow: current timestamp in nanoseconds plus the
 745                  * clock value converted to nanoseconds is outside the
 746                  * int64_t range.
 747                  */
 748                 clock_value->ns_from_epoch_overflows = true;
 749                 goto end;
 750         }
 751
 752 value_ok:
 753         clock_value->ns_from_epoch += s_ns;
 754
 755 end:
 756         if (clock_value->ns_from_epoch_overflows) {
 757                 clock_value->ns_from_epoch = 0;
 758         }
 759 }
 760
 761 struct bt_ctf_clock_value *bt_ctf_clock_value_create(
 762                 struct bt_ctf_clock_class *clock_class, uint64_t value)
 763 {
 764         struct bt_ctf_clock_value *ret = NULL;
 765
 766         BT_LOGD("Creating clock value object: clock-class-addr=%p, "
 767                 "clock-class-name=\"%s\", value=%" PRIu64, clock_class,
 768                 bt_ctf_clock_class_get_name(clock_class), value);
 769
 770         if (!clock_class) {
 771                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 772                 goto end;
 773         }
 774
 775         ret = g_new0(struct bt_ctf_clock_value, 1);
 776         if (!ret) {
 777                 BT_LOGE_STR("Failed to allocate one clock value.");
 778                 goto end;
 779         }
 780
 781         bt_object_init(ret, bt_ctf_clock_value_destroy);
 782         ret->clock_class = bt_get(clock_class);
 783         ret->value = value;
 784         set_ns_from_epoch(ret);
 785         bt_ctf_clock_class_freeze(clock_class);
 786         BT_LOGD("Created clock value object: clock-value-addr=%p, "
 787                 "clock-class-addr=%p, clock-class-name=\"%s\", "
 788                 "ns-from-epoch=%" PRId64 ", ns-from-epoch-overflows=%d",
 789                 ret, clock_class, bt_ctf_clock_class_get_name(clock_class),
 790                 ret->ns_from_epoch, ret->ns_from_epoch_overflows);
 791
 792 end:
 793         return ret;
 794 }
 795
 796 int bt_ctf_clock_value_get_value(
 797                 struct bt_ctf_clock_value *clock_value, uint64_t *raw_value)
 798 {
 799         int ret = 0;
 800
 801         if (!clock_value || !raw_value) {
 802                 BT_LOGW("Invalid parameter: clock value or raw value is NULL: "
 803                         "clock-value-addr=%p, raw-value-addr=%p",
 804                         clock_value, raw_value);
 805                 ret = -1;
 806                 goto end;
 807         }
 808
 809         *raw_value = clock_value->value;
 810 end:
 811         return ret;
 812 }
 813
 814 int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
 815                 int64_t *ret_value_ns)
 816 {
 817         int ret = 0;
 818
 819         if (!value || !ret_value_ns) {
 820                 BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: "
 821                         "clock-value-addr=%p, ret-value-addr=%p",
 822                         value, ret_value_ns);
 823                 ret = -1;
 824                 goto end;
 825         }
 826
 827         if (value->ns_from_epoch_overflows) {
 828                 BT_LOGW("Clock value converted to nanoseconds from Epoch overflows the signed 64-bit integer range: "
 829                         "clock-value-addr=%p, "
 830                         "clock-class-offset-s=%" PRId64 ", "
 831                         "clock-class-offset-cycles=%" PRId64 ", "
 832                         "value=%" PRIu64,
 833                         value, value->clock_class->offset_s,
 834                         value->clock_class->offset,
 835                         value->value);
 836                 ret = -1;
 837                 goto end;
 838         }
 839
 840         *ret_value_ns = value->ns_from_epoch;
 841
 842 end:
 843         return ret;
 844 }
 845
 846 struct bt_ctf_clock_class *bt_ctf_clock_value_get_class(
 847                 struct bt_ctf_clock_value *clock_value)
 848 {
 849         struct bt_ctf_clock_class *clock_class = NULL;
 850
 851         if (!clock_value) {
 852                 BT_LOGW_STR("Invalid parameter: clock value is NULL.");
 853                 goto end;
 854         }
 855
 856         clock_class = bt_get(clock_value->clock_class);
 857
 858 end:
 859         return clock_class;
 860 }