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/assert-pre-internal.h>
  33 #include <babeltrace/compat/uuid-internal.h>
  34 #include <babeltrace/ctf-ir/clock-class-internal.h>
  35 #include <babeltrace/ctf-ir/clock-value-internal.h>
  36 #include <babeltrace/ctf-ir/utils.h>
  37 #include <babeltrace/ref.h>
  38 #include <babeltrace/compiler-internal.h>
  39 #include <babeltrace/types.h>
  40 #include <babeltrace/compat/string-internal.h>
  41 #include <inttypes.h>
  42 #include <babeltrace/object-internal.h>
  43 #include <babeltrace/assert-internal.h>
  44
  45 static
  46 void bt_clock_class_destroy(struct bt_object *obj);
  47
  48 static
  49 struct bt_clock_value *bt_clock_value_new(struct bt_clock_class *clock_class);
  50
  51 static
  52 void bt_clock_value_destroy(struct bt_clock_value *clock_value);
  53
  54 BT_HIDDEN
  55 bt_bool bt_clock_class_is_valid(struct bt_clock_class *clock_class)
  56 {
  57         return clock_class && clock_class->name;
  58 }
  59
  60 int bt_clock_class_set_name(struct bt_clock_class *clock_class,
  61                 const char *name)
  62 {
  63         int ret = 0;
  64
  65         if (!clock_class) {
  66                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
  67                 ret = -1;
  68                 goto end;
  69         }
  70
  71         if (clock_class->frozen) {
  72                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
  73                         clock_class, bt_clock_class_get_name(clock_class));
  74                 ret = -1;
  75                 goto end;
  76         }
  77
  78         if (!bt_identifier_is_valid(name)) {
  79                 BT_LOGW("Clock class's name is not a valid CTF identifier: "
  80                         "addr=%p, name=\"%s\"",
  81                         clock_class, name);
  82                 ret = -1;
  83                 goto end;
  84         }
  85
  86         if (clock_class->name) {
  87                 g_string_assign(clock_class->name, name);
  88         } else {
  89                 clock_class->name = g_string_new(name);
  90                 if (!clock_class->name) {
  91                         BT_LOGE_STR("Failed to allocate a GString.");
  92                         ret = -1;
  93                         goto end;
  94                 }
  95         }
  96
  97         BT_LOGV("Set clock class's name: addr=%p, name=\"%s\"",
  98                 clock_class, name);
  99
 100 end:
 101         return ret;
 102 }
 103
 104 static
 105 bool validate_freq(struct bt_clock_class *clock_class,
 106                 const char *name, uint64_t freq)
 107 {
 108         bool is_valid = true;
 109
 110         if (freq == -1ULL || freq == 0) {
 111                 BT_LOGW("Invalid parameter: frequency is invalid: "
 112                         "addr=%p, name=\"%s\", freq=%" PRIu64,
 113                         clock_class, name, freq);
 114                 is_valid = false;
 115                 goto end;
 116         }
 117
 118 end:
 119         return is_valid;
 120 }
 121
 122 static
 123 void bt_clock_class_free_clock_value(struct bt_clock_value *clock_value,
 124                 struct bt_clock_class *clock_class)
 125 {
 126         bt_clock_value_destroy(clock_value);
 127 }
 128
 129 struct bt_clock_class *bt_clock_class_create(const char *name,
 130                 uint64_t freq)
 131 {
 132         int ret;
 133         struct bt_clock_class *clock_class = NULL;
 134
 135         BT_LOGD("Creating default clock class object: name=\"%s\"",
 136                 name);
 137
 138         if (!validate_freq(NULL, name, freq)) {
 139                 /* validate_freq() logs errors */
 140                 goto error;
 141         }
 142
 143         clock_class = g_new0(struct bt_clock_class, 1);
 144         if (!clock_class) {
 145                 BT_LOGE_STR("Failed to allocate one clock class.");
 146                 goto error;
 147         }
 148
 149         clock_class->precision = 1;
 150         clock_class->frequency = freq;
 151         bt_object_init_shared(&clock_class->base, bt_clock_class_destroy);
 152
 153         if (name) {
 154                 ret = bt_clock_class_set_name(clock_class, name);
 155                 if (ret) {
 156                         /* bt_clock_class_set_name() logs errors */
 157                         goto error;
 158                 }
 159         }
 160
 161         ret = bt_object_pool_initialize(&clock_class->cv_pool,
 162                 (bt_object_pool_new_object_func) bt_clock_value_new,
 163                 (bt_object_pool_destroy_object_func)
 164                         bt_clock_class_free_clock_value,
 165                 clock_class);
 166         if (ret) {
 167                 BT_LOGE("Failed to initialize clock value pool: ret=%d",
 168                         ret);
 169                 goto error;
 170         }
 171
 172         BT_LOGD("Created clock class object: addr=%p, name=\"%s\"",
 173                 clock_class, name);
 174         return clock_class;
 175 error:
 176         BT_PUT(clock_class);
 177         return clock_class;
 178 }
 179
 180 const char *bt_clock_class_get_name(struct bt_clock_class *clock_class)
 181 {
 182         const char *ret = NULL;
 183
 184         if (!clock_class) {
 185                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 186                 goto end;
 187         }
 188
 189         if (clock_class->name) {
 190                 ret = clock_class->name->str;
 191         }
 192
 193 end:
 194         return ret;
 195 }
 196
 197 const char *bt_clock_class_get_description(
 198                 struct bt_clock_class *clock_class)
 199 {
 200         const char *ret = NULL;
 201
 202         if (!clock_class) {
 203                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 204                 goto end;
 205         }
 206
 207         if (clock_class->description) {
 208                 ret = clock_class->description->str;
 209         }
 210 end:
 211         return ret;
 212 }
 213
 214 int bt_clock_class_set_description(struct bt_clock_class *clock_class,
 215                 const char *desc)
 216 {
 217         int ret = 0;
 218
 219         if (!clock_class || !desc) {
 220                 BT_LOGW("Invalid parameter: clock class or description is NULL: "
 221                         "clock-class-addr=%p, name=\"%s\", desc-addr=%p",
 222                         clock_class, bt_clock_class_get_name(clock_class),
 223                         desc);
 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_clock_class_get_name(clock_class));
 231                 ret = -1;
 232                 goto end;
 233         }
 234
 235         clock_class->description = g_string_new(desc);
 236         ret = clock_class->description ? 0 : -1;
 237         BT_LOGV("Set clock class's description: addr=%p, "
 238                 "name=\"%s\", desc=\"%s\"",
 239                 clock_class, bt_clock_class_get_name(clock_class), desc);
 240 end:
 241         return ret;
 242 }
 243
 244 uint64_t bt_clock_class_get_frequency(
 245                 struct bt_clock_class *clock_class)
 246 {
 247         uint64_t ret = -1ULL;
 248
 249         if (!clock_class) {
 250                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 251                 goto end;
 252         }
 253
 254         ret = clock_class->frequency;
 255 end:
 256         return ret;
 257 }
 258
 259 int bt_clock_class_set_frequency(struct bt_clock_class *clock_class,
 260                 uint64_t freq)
 261 {
 262         int ret = 0;
 263
 264         if (!clock_class) {
 265                 BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
 266                         "addr=%p, name=\"%s\"",
 267                         clock_class, bt_clock_class_get_name(clock_class));
 268                 ret = -1;
 269                 goto end;
 270         }
 271
 272         if (!validate_freq(clock_class, bt_clock_class_get_name(clock_class),
 273                         freq)) {
 274                 /* validate_freq() logs errors */
 275                 goto end;
 276         }
 277
 278         if (clock_class->frozen) {
 279                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 280                         clock_class, bt_clock_class_get_name(clock_class));
 281                 ret = -1;
 282                 goto end;
 283         }
 284
 285         clock_class->frequency = freq;
 286         BT_LOGV("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64,
 287                 clock_class, bt_clock_class_get_name(clock_class), freq);
 288 end:
 289         return ret;
 290 }
 291
 292 uint64_t bt_clock_class_get_precision(struct bt_clock_class *clock_class)
 293 {
 294         uint64_t ret = -1ULL;
 295
 296         if (!clock_class) {
 297                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 298                 goto end;
 299         }
 300
 301         ret = clock_class->precision;
 302 end:
 303         return ret;
 304 }
 305
 306 int bt_clock_class_set_precision(struct bt_clock_class *clock_class,
 307                 uint64_t precision)
 308 {
 309         int ret = 0;
 310
 311         if (!clock_class || precision == -1ULL) {
 312                 BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
 313                         "addr=%p, name=\"%s\", precision=%" PRIu64,
 314                         clock_class, bt_clock_class_get_name(clock_class),
 315                         precision);
 316                 ret = -1;
 317                 goto end;
 318         }
 319
 320         if (clock_class->frozen) {
 321                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 322                         clock_class, bt_clock_class_get_name(clock_class));
 323                 ret = -1;
 324                 goto end;
 325         }
 326
 327         clock_class->precision = precision;
 328         BT_LOGV("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64,
 329                 clock_class, bt_clock_class_get_name(clock_class),
 330                 precision);
 331 end:
 332         return ret;
 333 }
 334
 335 int bt_clock_class_get_offset_s(struct bt_clock_class *clock_class,
 336                 int64_t *offset_s)
 337 {
 338         int ret = 0;
 339
 340         if (!clock_class || !offset_s) {
 341                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 342                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 343                         clock_class, bt_clock_class_get_name(clock_class),
 344                         offset_s);
 345                 ret = -1;
 346                 goto end;
 347         }
 348
 349         *offset_s = clock_class->offset_s;
 350 end:
 351         return ret;
 352 }
 353
 354 int bt_clock_class_set_offset_s(struct bt_clock_class *clock_class,
 355                 int64_t offset_s)
 356 {
 357         int ret = 0;
 358
 359         if (!clock_class) {
 360                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 361                 ret = -1;
 362                 goto end;
 363         }
 364
 365         if (clock_class->frozen) {
 366                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 367                         clock_class, bt_clock_class_get_name(clock_class));
 368                 ret = -1;
 369                 goto end;
 370         }
 371
 372         clock_class->offset_s = offset_s;
 373         BT_LOGV("Set clock class's offset (seconds): "
 374                 "addr=%p, name=\"%s\", offset-s=%" PRId64,
 375                 clock_class, bt_clock_class_get_name(clock_class),
 376                 offset_s);
 377 end:
 378         return ret;
 379 }
 380
 381 int bt_clock_class_get_offset_cycles(struct bt_clock_class *clock_class,
 382                 int64_t *offset)
 383 {
 384         int ret = 0;
 385
 386         if (!clock_class || !offset) {
 387                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 388                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 389                         clock_class, bt_clock_class_get_name(clock_class),
 390                         offset);
 391                 ret = -1;
 392                 goto end;
 393         }
 394
 395         *offset = clock_class->offset;
 396 end:
 397         return ret;
 398 }
 399
 400 int bt_clock_class_set_offset_cycles(struct bt_clock_class *clock_class,
 401                 int64_t offset)
 402 {
 403         int ret = 0;
 404
 405         if (!clock_class) {
 406                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 407                 ret = -1;
 408                 goto end;
 409         }
 410
 411         if (clock_class->frozen) {
 412                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 413                         clock_class, bt_clock_class_get_name(clock_class));
 414                 ret = -1;
 415                 goto end;
 416         }
 417
 418         clock_class->offset = offset;
 419         BT_LOGV("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64,
 420                 clock_class, bt_clock_class_get_name(clock_class), offset);
 421 end:
 422         return ret;
 423 }
 424
 425 bt_bool bt_clock_class_is_absolute(struct bt_clock_class *clock_class)
 426 {
 427         int ret = -1;
 428
 429         if (!clock_class) {
 430                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 431                 goto end;
 432         }
 433
 434         ret = clock_class->absolute;
 435 end:
 436         return ret;
 437 }
 438
 439 int bt_clock_class_set_is_absolute(struct bt_clock_class *clock_class,
 440                 bt_bool is_absolute)
 441 {
 442         int ret = 0;
 443
 444         if (!clock_class) {
 445                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 446                 ret = -1;
 447                 goto end;
 448         }
 449
 450         if (clock_class->frozen) {
 451                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 452                         clock_class, bt_clock_class_get_name(clock_class));
 453                 ret = -1;
 454                 goto end;
 455         }
 456
 457         clock_class->absolute = !!is_absolute;
 458         BT_LOGV("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d",
 459                 clock_class, bt_clock_class_get_name(clock_class),
 460                 is_absolute);
 461 end:
 462         return ret;
 463 }
 464
 465 const unsigned char *bt_clock_class_get_uuid(
 466                 struct bt_clock_class *clock_class)
 467 {
 468         const unsigned char *ret;
 469
 470         if (!clock_class) {
 471                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 472                 ret = NULL;
 473                 goto end;
 474         }
 475
 476         if (!clock_class->uuid_set) {
 477                 BT_LOGV("Clock class's UUID is not set: addr=%p, name=\"%s\"",
 478                         clock_class, bt_clock_class_get_name(clock_class));
 479                 ret = NULL;
 480                 goto end;
 481         }
 482
 483         ret = clock_class->uuid;
 484 end:
 485         return ret;
 486 }
 487
 488 int bt_clock_class_set_uuid(struct bt_clock_class *clock_class,
 489                 const unsigned char *uuid)
 490 {
 491         int ret = 0;
 492
 493         if (!clock_class || !uuid) {
 494                 BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
 495                         "clock-class-addr=%p, name=\"%s\", uuid-addr=%p",
 496                         clock_class, bt_clock_class_get_name(clock_class),
 497                         uuid);
 498                 ret = -1;
 499                 goto end;
 500         }
 501
 502         if (clock_class->frozen) {
 503                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 504                         clock_class, bt_clock_class_get_name(clock_class));
 505                 ret = -1;
 506                 goto end;
 507         }
 508
 509         memcpy(clock_class->uuid, uuid, BABELTRACE_UUID_LEN);
 510         clock_class->uuid_set = 1;
 511         BT_LOGV("Set clock class's UUID: addr=%p, name=\"%s\", "
 512                 "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 513                 clock_class, bt_clock_class_get_name(clock_class),
 514                 (unsigned int) uuid[0],
 515                 (unsigned int) uuid[1],
 516                 (unsigned int) uuid[2],
 517                 (unsigned int) uuid[3],
 518                 (unsigned int) uuid[4],
 519                 (unsigned int) uuid[5],
 520                 (unsigned int) uuid[6],
 521                 (unsigned int) uuid[7],
 522                 (unsigned int) uuid[8],
 523                 (unsigned int) uuid[9],
 524                 (unsigned int) uuid[10],
 525                 (unsigned int) uuid[11],
 526                 (unsigned int) uuid[12],
 527                 (unsigned int) uuid[13],
 528                 (unsigned int) uuid[14],
 529                 (unsigned int) uuid[15]);
 530 end:
 531         return ret;
 532 }
 533
 534 static inline
 535 uint64_t ns_from_value(uint64_t frequency, uint64_t value)
 536 {
 537         uint64_t ns;
 538
 539         if (frequency == UINT64_C(1000000000)) {
 540                 ns = value;
 541         } else {
 542                 double dblres = ((1e9 * (double) value) / (double) frequency);
 543
 544                 if (dblres >= (double) UINT64_MAX) {
 545                         /* Overflows uint64_t */
 546                         ns = -1ULL;
 547                 } else {
 548                         ns = (uint64_t) dblres;
 549                 }
 550         }
 551
 552         return ns;
 553 }
 554
 555 BT_HIDDEN
 556 void bt_clock_class_freeze(struct bt_clock_class *clock_class)
 557 {
 558         if (!clock_class || clock_class->frozen) {
 559                 return;
 560         }
 561
 562         BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"",
 563                 clock_class, bt_clock_class_get_name(clock_class));
 564         clock_class->frozen = 1;
 565 }
 566
 567 static
 568 void bt_clock_class_destroy(struct bt_object *obj)
 569 {
 570         struct bt_clock_class *clock_class;
 571
 572         clock_class = container_of(obj, struct bt_clock_class, base);
 573         BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"",
 574                 obj, bt_clock_class_get_name(clock_class));
 575
 576         if (clock_class->name) {
 577                 g_string_free(clock_class->name, TRUE);
 578         }
 579
 580         if (clock_class->description) {
 581                 g_string_free(clock_class->description, TRUE);
 582         }
 583
 584         bt_object_pool_finalize(&clock_class->cv_pool);
 585         g_free(clock_class);
 586 }
 587
 588 static
 589 void bt_clock_value_destroy(struct bt_clock_value *clock_value)
 590 {
 591         BT_LOGD("Destroying clock value: addr=%p, clock-class-addr=%p, "
 592                 "clock-class-name=\"%s\"", clock_value,
 593                 clock_value->clock_class,
 594                 bt_clock_class_get_name(clock_value->clock_class));
 595         bt_put(clock_value->clock_class);
 596         g_free(clock_value);
 597 }
 598
 599 static inline
 600 int ns_from_epoch(struct bt_clock_class *clock_class, uint64_t value,
 601                 int64_t *ns_from_epoch, bool *overflows)
 602 {
 603         int ret = 0;
 604         int64_t diff;
 605         int64_t s_ns;
 606         uint64_t u_ns;
 607         uint64_t cycles;
 608
 609         *overflows = false;
 610
 611         /* Initialize nanosecond timestamp to clock's offset in seconds */
 612         if (clock_class->offset_s <= (INT64_MIN / INT64_C(1000000000)) ||
 613                         clock_class->offset_s >= (INT64_MAX / INT64_C(1000000000))) {
 614                 /*
 615                  * Overflow: offset in seconds converted to nanoseconds
 616                  * is outside the int64_t range.
 617                  */
 618                 *overflows = true;
 619                 goto end;
 620         }
 621
 622         *ns_from_epoch = clock_class->offset_s * INT64_C(1000000000);
 623
 624         /* Add offset in cycles */
 625         if (clock_class->offset < 0) {
 626                 cycles = (uint64_t) -clock_class->offset;
 627         } else {
 628                 cycles = (uint64_t) clock_class->offset;
 629         }
 630
 631         u_ns = ns_from_value(clock_class->frequency, cycles);
 632
 633         if (u_ns == UINT64_C(-1) || u_ns >= INT64_MAX) {
 634                 /*
 635                  * Overflow: offset in cycles converted to nanoseconds
 636                  * is outside the int64_t range.
 637                  */
 638                 *overflows = true;
 639                 goto end;
 640         }
 641
 642         s_ns = (int64_t) u_ns;
 643         BT_ASSERT(s_ns >= 0);
 644
 645         if (clock_class->offset < 0) {
 646                 if (*ns_from_epoch >= 0) {
 647                         /*
 648                          * Offset in cycles is negative so it must also
 649                          * be negative once converted to nanoseconds.
 650                          */
 651                         s_ns = -s_ns;
 652                         goto offset_ok;
 653                 }
 654
 655                 diff = *ns_from_epoch - INT64_MIN;
 656
 657                 if (s_ns >= diff) {
 658                         /*
 659                          * Overflow: current timestamp in nanoseconds
 660                          * plus the offset in cycles converted to
 661                          * nanoseconds is outside the int64_t range.
 662                          */
 663                         *overflows = true;
 664                         goto end;
 665                 }
 666
 667                 /*
 668                  * Offset in cycles is negative so it must also be
 669                  * negative once converted to nanoseconds.
 670                  */
 671                 s_ns = -s_ns;
 672         } else {
 673                 if (*ns_from_epoch <= 0) {
 674                         goto offset_ok;
 675                 }
 676
 677                 diff = INT64_MAX - *ns_from_epoch;
 678
 679                 if (s_ns >= diff) {
 680                         /*
 681                          * Overflow: current timestamp in nanoseconds
 682                          * plus the offset in cycles converted to
 683                          * nanoseconds is outside the int64_t range.
 684                          */
 685                         *overflows = true;
 686                         goto end;
 687                 }
 688         }
 689
 690 offset_ok:
 691         *ns_from_epoch += s_ns;
 692
 693         /* Add clock value (cycles) */
 694         u_ns = ns_from_value(clock_class->frequency, value);
 695
 696         if (u_ns == -1ULL || u_ns >= INT64_MAX) {
 697                 /*
 698                  * Overflow: value converted to nanoseconds is outside
 699                  * the int64_t range.
 700                  */
 701                 *overflows = true;
 702                 goto end;
 703         }
 704
 705         s_ns = (int64_t) u_ns;
 706         BT_ASSERT(s_ns >= 0);
 707
 708         /* Clock value (cycles) is always positive */
 709         if (*ns_from_epoch <= 0) {
 710                 goto value_ok;
 711         }
 712
 713         diff = INT64_MAX - *ns_from_epoch;
 714
 715         if (s_ns >= diff) {
 716                 /*
 717                  * Overflow: current timestamp in nanoseconds plus the
 718                  * clock value converted to nanoseconds is outside the
 719                  * int64_t range.
 720                  */
 721                 *overflows = true;
 722                 goto end;
 723         }
 724
 725 value_ok:
 726         *ns_from_epoch += s_ns;
 727
 728 end:
 729         if (*overflows) {
 730                 *ns_from_epoch = 0;
 731                 ret = -1;
 732         }
 733
 734         return ret;
 735 }
 736
 737 static
 738 void set_ns_from_epoch(struct bt_clock_value *clock_value)
 739 {
 740         (void) ns_from_epoch(clock_value->clock_class,
 741                 clock_value->value, &clock_value->ns_from_epoch,
 742                 &clock_value->ns_from_epoch_overflows);
 743 }
 744
 745 static
 746 struct bt_clock_value *bt_clock_value_new(struct bt_clock_class *clock_class)
 747 {
 748         struct bt_clock_value *ret = NULL;
 749
 750         BT_LOGD("Creating clock value object: clock-class-addr=%p, "
 751                 "clock-class-name=\"%s\"", clock_class,
 752                 bt_clock_class_get_name(clock_class));
 753
 754         if (!clock_class) {
 755                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 756                 goto end;
 757         }
 758
 759         ret = g_new0(struct bt_clock_value, 1);
 760         if (!ret) {
 761                 BT_LOGE_STR("Failed to allocate one clock value.");
 762                 goto end;
 763         }
 764
 765         bt_object_init_unique(&ret->base);
 766         ret->clock_class = bt_get(clock_class);
 767         bt_clock_class_freeze(clock_class);
 768         BT_LOGD("Created clock value object: clock-value-addr=%p, "
 769                 "clock-class-addr=%p, clock-class-name=\"%s\", "
 770                 "ns-from-epoch=%" PRId64 ", ns-from-epoch-overflows=%d",
 771                 ret, clock_class, bt_clock_class_get_name(clock_class),
 772                 ret->ns_from_epoch, ret->ns_from_epoch_overflows);
 773
 774 end:
 775         return ret;
 776 }
 777
 778 BT_HIDDEN
 779 struct bt_clock_value *bt_clock_value_create(struct bt_clock_class *clock_class)
 780 {
 781         struct bt_clock_value *clock_value = NULL;
 782
 783         BT_ASSERT(clock_class);
 784         clock_value = bt_object_pool_create_object(&clock_class->cv_pool);
 785         if (!clock_value) {
 786                 BT_LIB_LOGE("Cannot allocate one clock value from clock class's clock value pool: "
 787                         "%![cc-]+K", clock_class);
 788                 goto error;
 789         }
 790
 791         if (!clock_value->clock_class) {
 792                 clock_value->clock_class = bt_get(clock_class);
 793         }
 794
 795         goto end;
 796
 797 error:
 798         if (clock_value) {
 799                 bt_clock_value_recycle(clock_value);
 800                 clock_value = NULL;
 801         }
 802
 803 end:
 804         return clock_value;
 805 }
 806
 807 BT_HIDDEN
 808 void bt_clock_value_recycle(struct bt_clock_value *clock_value)
 809 {
 810         struct bt_clock_class *clock_class;
 811
 812         BT_ASSERT(clock_value);
 813         BT_LIB_LOGD("Recycling clock value: %!+k", clock_value);
 814
 815         /*
 816          * Those are the important ordered steps:
 817          *
 818          * 1. Reset the clock value object, but do NOT put its clock
 819          *    class's reference. This clock class contains the pool to
 820          *    which we're about to recycle this clock value object, so
 821          *    we must guarantee its existence thanks to this existing
 822          *    reference.
 823          *
 824          * 2. Move the clock class reference to our `clock_class`
 825          *    variable so that we can set the clock value's clock class
 826          *    member to NULL before recycling it. We CANNOT do this
 827          *    after we put the clock class reference because this
 828          *    bt_put() could destroy the clock class, also destroying
 829          *    its clock value pool, thus also destroying our clock value
 830          *    object (this would result in an invalid write access).
 831          *
 832          * 3. Recycle the clock value object.
 833          *
 834          * 4. Put our clock class reference.
 835          */
 836         bt_clock_value_reset(clock_value);
 837         bt_clock_value_set_is_frozen(clock_value, false);
 838         clock_class = clock_value->clock_class;
 839         BT_ASSERT(clock_class);
 840         clock_value->clock_class = NULL;
 841         bt_object_pool_recycle_object(&clock_class->cv_pool, clock_value);
 842         bt_put(clock_class);
 843 }
 844
 845 BT_HIDDEN
 846 void bt_clock_value_set_raw_value(struct bt_clock_value *clock_value,
 847                 uint64_t cycles)
 848 {
 849         BT_ASSERT(clock_value);
 850
 851         clock_value->value = cycles;
 852         set_ns_from_epoch(clock_value);
 853         bt_clock_value_set(clock_value);
 854 }
 855
 856 int bt_clock_value_set_value(struct bt_clock_value *clock_value,
 857                 uint64_t raw_value)
 858 {
 859         BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value");
 860         BT_ASSERT_PRE_HOT(clock_value, "Clock value", ": %!+k", clock_value);
 861         bt_clock_value_set_raw_value(clock_value, raw_value);
 862         return 0;
 863 }
 864
 865 int bt_clock_value_get_value(struct bt_clock_value *clock_value,
 866                 uint64_t *raw_value)
 867 {
 868         int ret = 0;
 869
 870         if (!clock_value || !raw_value) {
 871                 BT_LOGW("Invalid parameter: clock value or raw value is NULL: "
 872                         "clock-value-addr=%p, raw-value-addr=%p",
 873                         clock_value, raw_value);
 874                 ret = -1;
 875                 goto end;
 876         }
 877
 878         *raw_value = clock_value->value;
 879 end:
 880         return ret;
 881 }
 882
 883 int bt_clock_value_get_value_ns_from_epoch(struct bt_clock_value *value,
 884                 int64_t *ret_value_ns)
 885 {
 886         int ret = 0;
 887
 888         if (!value || !ret_value_ns) {
 889                 BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: "
 890                         "clock-value-addr=%p, ret-value-addr=%p",
 891                         value, ret_value_ns);
 892                 ret = -1;
 893                 goto end;
 894         }
 895
 896         if (value->ns_from_epoch_overflows) {
 897                 BT_LOGW("Clock value converted to nanoseconds from Epoch overflows the signed 64-bit integer range: "
 898                         "clock-value-addr=%p, "
 899                         "clock-class-offset-s=%" PRId64 ", "
 900                         "clock-class-offset-cycles=%" PRId64 ", "
 901                         "value=%" PRIu64,
 902                         value, value->clock_class->offset_s,
 903                         value->clock_class->offset,
 904                         value->value);
 905                 ret = -1;
 906                 goto end;
 907         }
 908
 909         *ret_value_ns = value->ns_from_epoch;
 910
 911 end:
 912         return ret;
 913 }
 914
 915 struct bt_clock_class *bt_clock_value_borrow_class(
 916                 struct bt_clock_value *clock_value)
 917 {
 918         struct bt_clock_class *clock_class = NULL;
 919
 920         if (!clock_value) {
 921                 BT_LOGW_STR("Invalid parameter: clock value is NULL.");
 922                 goto end;
 923         }
 924
 925         clock_class = clock_value->clock_class;
 926
 927 end:
 928         return clock_class;
 929 }
 930
 931 BT_HIDDEN
 932 int bt_clock_class_compare(struct bt_clock_class *clock_class_a,
 933                 struct bt_clock_class *clock_class_b)
 934 {
 935         int ret = 1;
 936         BT_ASSERT(clock_class_a);
 937         BT_ASSERT(clock_class_b);
 938
 939         /* Name */
 940         if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) {
 941                 BT_LOGV("Clock classes differ: different names: "
 942                         "cc-a-name=\"%s\", cc-b-name=\"%s\"",
 943                         clock_class_a->name->str,
 944                         clock_class_b->name->str);
 945                 goto end;
 946         }
 947
 948         /* Description */
 949         if (clock_class_a->description) {
 950                 if (!clock_class_b->description) {
 951                         BT_LOGV_STR("Clock classes differ: clock class A has a "
 952                                 "description, but clock class B does not.");
 953                         goto end;
 954                 }
 955
 956                 if (strcmp(clock_class_a->name->str, clock_class_b->name->str)
 957                                 != 0) {
 958                         BT_LOGV("Clock classes differ: different descriptions: "
 959                                 "cc-a-descr=\"%s\", cc-b-descr=\"%s\"",
 960                                 clock_class_a->description->str,
 961                                 clock_class_b->description->str);
 962                         goto end;
 963                 }
 964         } else {
 965                 if (clock_class_b->description) {
 966                         BT_LOGV_STR("Clock classes differ: clock class A has "
 967                                 "no description, but clock class B has one.");
 968                         goto end;
 969                 }
 970         }
 971
 972         /* Frequency */
 973         if (clock_class_a->frequency != clock_class_b->frequency) {
 974                 BT_LOGV("Clock classes differ: different frequencies: "
 975                         "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
 976                         clock_class_a->frequency,
 977                         clock_class_b->frequency);
 978                 goto end;
 979         }
 980
 981         /* Precision */
 982         if (clock_class_a->precision != clock_class_b->precision) {
 983                 BT_LOGV("Clock classes differ: different precisions: "
 984                         "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
 985                         clock_class_a->precision,
 986                         clock_class_b->precision);
 987                 goto end;
 988         }
 989
 990         /* Offset (seconds) */
 991         if (clock_class_a->offset_s != clock_class_b->offset_s) {
 992                 BT_LOGV("Clock classes differ: different offsets (seconds): "
 993                         "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
 994                         clock_class_a->offset_s,
 995                         clock_class_b->offset_s);
 996                 goto end;
 997         }
 998
 999         /* Offset (cycles) */
1000         if (clock_class_a->offset != clock_class_b->offset) {
1001                 BT_LOGV("Clock classes differ: different offsets (cycles): "
1002                         "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
1003                         clock_class_a->offset,
1004                         clock_class_b->offset);
1005                 goto end;
1006         }
1007
1008         /* UUIDs */
1009         if (clock_class_a->uuid_set) {
1010                 if (!clock_class_b->uuid_set) {
1011                         BT_LOGV_STR("Clock classes differ: clock class A has a "
1012                                 "UUID, but clock class B does not.");
1013                         goto end;
1014                 }
1015
1016                 if (memcmp(clock_class_a->uuid, clock_class_b->uuid,
1017                                 BABELTRACE_UUID_LEN) != 0) {
1018                         BT_LOGV("Clock classes differ: different UUIDs: "
1019                                 "cc-a-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
1020                                 "cc-b-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
1021                                 (unsigned int) clock_class_a->uuid[0],
1022                                 (unsigned int) clock_class_a->uuid[1],
1023                                 (unsigned int) clock_class_a->uuid[2],
1024                                 (unsigned int) clock_class_a->uuid[3],
1025                                 (unsigned int) clock_class_a->uuid[4],
1026                                 (unsigned int) clock_class_a->uuid[5],
1027                                 (unsigned int) clock_class_a->uuid[6],
1028                                 (unsigned int) clock_class_a->uuid[7],
1029                                 (unsigned int) clock_class_a->uuid[8],
1030                                 (unsigned int) clock_class_a->uuid[9],
1031                                 (unsigned int) clock_class_a->uuid[10],
1032                                 (unsigned int) clock_class_a->uuid[11],
1033                                 (unsigned int) clock_class_a->uuid[12],
1034                                 (unsigned int) clock_class_a->uuid[13],
1035                                 (unsigned int) clock_class_a->uuid[14],
1036                                 (unsigned int) clock_class_a->uuid[15],
1037                                 (unsigned int) clock_class_b->uuid[0],
1038                                 (unsigned int) clock_class_b->uuid[1],
1039                                 (unsigned int) clock_class_b->uuid[2],
1040                                 (unsigned int) clock_class_b->uuid[3],
1041                                 (unsigned int) clock_class_b->uuid[4],
1042                                 (unsigned int) clock_class_b->uuid[5],
1043                                 (unsigned int) clock_class_b->uuid[6],
1044                                 (unsigned int) clock_class_b->uuid[7],
1045                                 (unsigned int) clock_class_b->uuid[8],
1046                                 (unsigned int) clock_class_b->uuid[9],
1047                                 (unsigned int) clock_class_b->uuid[10],
1048                                 (unsigned int) clock_class_b->uuid[11],
1049                                 (unsigned int) clock_class_b->uuid[12],
1050                                 (unsigned int) clock_class_b->uuid[13],
1051                                 (unsigned int) clock_class_b->uuid[14],
1052                                 (unsigned int) clock_class_b->uuid[15]);
1053                         goto end;
1054                 }
1055         } else {
1056                 if (clock_class_b->uuid_set) {
1057                         BT_LOGV_STR("Clock classes differ: clock class A has "
1058                                 "no UUID, but clock class B has one.");
1059                         goto end;
1060                 }
1061         }
1062
1063         /* Absolute */
1064         if (!!clock_class_a->absolute != !!clock_class_b->absolute) {
1065                 BT_LOGV("Clock classes differ: one is absolute, the other "
1066                         "is not: cc-a-is-absolute=%d, cc-b-is-absolute=%d",
1067                         !!clock_class_a->absolute,
1068                         !!clock_class_b->absolute);
1069                 goto end;
1070         }
1071
1072         /* Equal */
1073         ret = 0;
1074
1075 end:
1076         return ret;
1077 }
1078
1079 int bt_clock_class_cycles_to_ns(struct bt_clock_class *clock_class,
1080                 uint64_t cycles, int64_t *ns)
1081 {
1082         int ret;
1083         bool overflows;
1084
1085         BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
1086         BT_ASSERT_PRE_NON_NULL(ns, "Nanoseconds");
1087
1088         ret = ns_from_epoch(clock_class, cycles, ns, &overflows);
1089         if (ret) {
1090                 if (overflows) {
1091                         BT_LIB_LOGW("Cannot convert cycles to nanoseconds "
1092                                 "from Epoch for given clock class: "
1093                                 "value overflow: %![cc-]+K, cycles=%" PRIu64,
1094                                 clock_class, cycles);
1095                 } else {
1096                         BT_LIB_LOGW("Cannot convert cycles to nanoseconds "
1097                                 "from Epoch for given clock class: "
1098                                 "%![cc-]+K, cycles=%" PRIu64,
1099                                 clock_class, cycles);
1100                 }
1101
1102                 goto end;
1103         }
1104
1105 end:
1106         return ret;
1107 }