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 #include <babeltrace/ctf-ir/clock-class-internal.h>
  30 #include <babeltrace/ctf-ir/utils.h>
  31 #include <babeltrace/ref.h>
  32 #include <babeltrace/object-internal.h>
  33 #include <babeltrace/compiler-internal.h>
  34 #include <babeltrace/types.h>
  35 #include <inttypes.h>
  36
  37 #define BT_LOG_TAG "CLOCK-CLASS"
  38 #include <babeltrace/lib-logging-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",
  62                         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                         "clock-class-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: clock-class-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                                 "clock-class-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", clock_class);
 128         return clock_class;
 129 error:
 130         BT_PUT(clock_class);
 131         return clock_class;
 132 }
 133
 134 const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class)
 135 {
 136         const char *ret = NULL;
 137
 138         if (!clock_class) {
 139                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 140                 goto end;
 141         }
 142
 143         if (clock_class->name) {
 144                 ret = clock_class->name->str;
 145         }
 146
 147 end:
 148         return ret;
 149 }
 150
 151 const char *bt_ctf_clock_class_get_description(
 152                 struct bt_ctf_clock_class *clock_class)
 153 {
 154         const char *ret = NULL;
 155
 156         if (!clock_class) {
 157                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 158                 goto end;
 159         }
 160
 161         if (clock_class->description) {
 162                 ret = clock_class->description->str;
 163         }
 164 end:
 165         return ret;
 166 }
 167
 168 int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
 169                 const char *desc)
 170 {
 171         int ret = 0;
 172
 173         if (!clock_class || !desc) {
 174                 BT_LOGW("Invalid parameter: clock class or description is NULL: "
 175                         "clock-class-addr=%p, desc-addr=%p",
 176                         clock_class, desc);
 177                 ret = -1;
 178                 goto end;
 179         }
 180
 181         if (clock_class->frozen) {
 182                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 183                         clock_class);
 184                 ret = -1;
 185                 goto end;
 186         }
 187
 188         clock_class->description = g_string_new(desc);
 189         ret = clock_class->description ? 0 : -1;
 190         BT_LOGV("Set clock class's description: clock-class-addr=%p, desc=\"%s\"",
 191                 clock_class, desc);
 192 end:
 193         return ret;
 194 }
 195
 196 uint64_t bt_ctf_clock_class_get_frequency(
 197                 struct bt_ctf_clock_class *clock_class)
 198 {
 199         uint64_t ret = -1ULL;
 200
 201         if (!clock_class) {
 202                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 203                 goto end;
 204         }
 205
 206         ret = clock_class->frequency;
 207 end:
 208         return ret;
 209 }
 210
 211 int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
 212                 uint64_t freq)
 213 {
 214         int ret = 0;
 215
 216         if (!clock_class || freq == -1ULL) {
 217                 BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
 218                         "clock-class-addr=%p, freq=%" PRIu64,
 219                         clock_class, freq);
 220                 ret = -1;
 221                 goto end;
 222         }
 223
 224         if (clock_class->frozen) {
 225                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 226                         clock_class);
 227                 ret = -1;
 228                 goto end;
 229         }
 230
 231         clock_class->frequency = freq;
 232         BT_LOGV("Set clock class's frequency: clock-class-addr=%p, freq=%" PRIu64,
 233                 clock_class, freq);
 234 end:
 235         return ret;
 236 }
 237
 238 uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
 239 {
 240         uint64_t ret = -1ULL;
 241
 242         if (!clock_class) {
 243                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 244                 goto end;
 245         }
 246
 247         ret = clock_class->precision;
 248 end:
 249         return ret;
 250 }
 251
 252 int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
 253                 uint64_t precision)
 254 {
 255         int ret = 0;
 256
 257         if (!clock_class || precision == -1ULL) {
 258                 BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
 259                         "clock-class-addr=%p, precision=%" PRIu64,
 260                         clock_class, precision);
 261                 ret = -1;
 262                 goto end;
 263         }
 264
 265         if (clock_class->frozen) {
 266                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 267                         clock_class);
 268                 ret = -1;
 269                 goto end;
 270         }
 271
 272         clock_class->precision = precision;
 273         BT_LOGV("Set clock class's precision: clock-class-addr=%p, precision=%" PRIu64,
 274                 clock_class, precision);
 275 end:
 276         return ret;
 277 }
 278
 279 int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
 280                 int64_t *offset_s)
 281 {
 282         int ret = 0;
 283
 284         if (!clock_class || !offset_s) {
 285                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 286                         "clock-class-addr=%p, offset-addr=%p",
 287                         clock_class, offset_s);
 288                 ret = -1;
 289                 goto end;
 290         }
 291
 292         *offset_s = clock_class->offset_s;
 293 end:
 294         return ret;
 295 }
 296
 297 int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
 298                 int64_t offset_s)
 299 {
 300         int ret = 0;
 301
 302         if (!clock_class) {
 303                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 304                 ret = -1;
 305                 goto end;
 306         }
 307
 308         if (clock_class->frozen) {
 309                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 310                         clock_class);
 311                 ret = -1;
 312                 goto end;
 313         }
 314
 315         clock_class->offset_s = offset_s;
 316         BT_LOGV("Set clock class's offset (seconds): clock-class-addr=%p, offset-s=%" PRId64,
 317                 clock_class, offset_s);
 318 end:
 319         return ret;
 320 }
 321
 322 int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
 323                 int64_t *offset)
 324 {
 325         int ret = 0;
 326
 327         if (!clock_class || !offset) {
 328                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 329                         "clock-class-addr=%p, offset-addr=%p",
 330                         clock_class, offset);
 331                 ret = -1;
 332                 goto end;
 333         }
 334
 335         *offset = clock_class->offset;
 336 end:
 337         return ret;
 338 }
 339
 340 int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
 341                 int64_t offset)
 342 {
 343         int ret = 0;
 344
 345         if (!clock_class) {
 346                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 347                 ret = -1;
 348                 goto end;
 349         }
 350
 351         if (clock_class->frozen) {
 352                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 353                         clock_class);
 354                 ret = -1;
 355                 goto end;
 356         }
 357
 358         clock_class->offset = offset;
 359         BT_LOGV("Set clock class's offset (cycles): clock-class-addr=%p, offset-cycles=%" PRId64,
 360                 clock_class, offset);
 361 end:
 362         return ret;
 363 }
 364
 365 bt_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
 366 {
 367         int ret = -1;
 368
 369         if (!clock_class) {
 370                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 371                 goto end;
 372         }
 373
 374         ret = clock_class->absolute;
 375 end:
 376         return ret;
 377 }
 378
 379 int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
 380                 bt_bool is_absolute)
 381 {
 382         int ret = 0;
 383
 384         if (!clock_class) {
 385                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 386                 ret = -1;
 387                 goto end;
 388         }
 389
 390         if (clock_class->frozen) {
 391                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 392                         clock_class);
 393                 ret = -1;
 394                 goto end;
 395         }
 396
 397         clock_class->absolute = !!is_absolute;
 398         BT_LOGV("Set clock class's absolute flag: clock-class-addr=%p, is-absolute=%d",
 399                 clock_class, !!is_absolute);
 400 end:
 401         return ret;
 402 }
 403
 404 const unsigned char *bt_ctf_clock_class_get_uuid(
 405                 struct bt_ctf_clock_class *clock_class)
 406 {
 407         const unsigned char *ret;
 408
 409         if (!clock_class) {
 410                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 411                 ret = NULL;
 412                 goto end;
 413         }
 414
 415         if (!clock_class->uuid_set) {
 416                 BT_LOGV("Clock class's UUID is not set: clock-class-addr=%p",
 417                         clock_class);
 418                 ret = NULL;
 419                 goto end;
 420         }
 421
 422         ret = clock_class->uuid;
 423 end:
 424         return ret;
 425 }
 426
 427 int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
 428                 const unsigned char *uuid)
 429 {
 430         int ret = 0;
 431
 432         if (!clock_class || !uuid) {
 433                 BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
 434                         "clock-class-addr=%p, uuid-addr=%p",
 435                         clock_class, uuid);
 436                 ret = -1;
 437                 goto end;
 438         }
 439
 440         if (clock_class->frozen) {
 441                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
 442                         clock_class);
 443                 ret = -1;
 444                 goto end;
 445         }
 446
 447         memcpy(clock_class->uuid, uuid, sizeof(uuid_t));
 448         clock_class->uuid_set = 1;
 449         BT_LOGV("Set clock class's UUID: clock-class-addr=%p, "
 450                 "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 451                 clock_class,
 452                 (unsigned int) uuid[0],
 453                 (unsigned int) uuid[1],
 454                 (unsigned int) uuid[2],
 455                 (unsigned int) uuid[3],
 456                 (unsigned int) uuid[4],
 457                 (unsigned int) uuid[5],
 458                 (unsigned int) uuid[6],
 459                 (unsigned int) uuid[7],
 460                 (unsigned int) uuid[8],
 461                 (unsigned int) uuid[9],
 462                 (unsigned int) uuid[10],
 463                 (unsigned int) uuid[11],
 464                 (unsigned int) uuid[12],
 465                 (unsigned int) uuid[13],
 466                 (unsigned int) uuid[14],
 467                 (unsigned int) uuid[15]);
 468 end:
 469         return ret;
 470 }
 471
 472 static uint64_t ns_from_value(uint64_t frequency, uint64_t value)
 473 {
 474         uint64_t ns;
 475
 476         if (frequency == 1000000000) {
 477                 ns = value;
 478         } else {
 479                 ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
 480         }
 481
 482         return ns;
 483 }
 484
 485 BT_HIDDEN
 486 void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
 487 {
 488         if (!clock_class) {
 489                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 490                 return;
 491         }
 492
 493         if (!clock_class->frozen) {
 494                 BT_LOGD("Freezing clock class: addr=%p", clock_class);
 495                 clock_class->frozen = 1;
 496         }
 497 }
 498
 499 BT_HIDDEN
 500 void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
 501                 struct metadata_context *context)
 502 {
 503         unsigned char *uuid;
 504
 505         BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
 506                 "metadata-context-addr=%p", clock_class, context);
 507
 508         if (!clock_class || !context) {
 509                 BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
 510                         "clock-class-addr=%p, metadata-context-addr=%p",
 511                         clock_class, context);
 512                 return;
 513         }
 514
 515         uuid = clock_class->uuid;
 516         g_string_append(context->string, "clock {\n");
 517         g_string_append_printf(context->string, "\tname = %s;\n",
 518                 clock_class->name->str);
 519         g_string_append_printf(context->string,
 520                 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 521                 uuid[0], uuid[1], uuid[2], uuid[3],
 522                 uuid[4], uuid[5], uuid[6], uuid[7],
 523                 uuid[8], uuid[9], uuid[10], uuid[11],
 524                 uuid[12], uuid[13], uuid[14], uuid[15]);
 525         if (clock_class->description) {
 526                 g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
 527                         clock_class->description->str);
 528         }
 529
 530         g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
 531                 clock_class->frequency);
 532         g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
 533                 clock_class->precision);
 534         g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
 535                 clock_class->offset_s);
 536         g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
 537                 clock_class->offset);
 538         g_string_append_printf(context->string, "\tabsolute = %s;\n",
 539                 clock_class->absolute ? "TRUE" : "FALSE");
 540         g_string_append(context->string, "};\n\n");
 541 }
 542
 543 static
 544 void bt_ctf_clock_class_destroy(struct bt_object *obj)
 545 {
 546         struct bt_ctf_clock_class *clock_class;
 547
 548         BT_LOGD("Destroying clock class: addr=%p", obj);
 549         clock_class = container_of(obj, struct bt_ctf_clock_class, base);
 550         if (clock_class->name) {
 551                 g_string_free(clock_class->name, TRUE);
 552         }
 553         if (clock_class->description) {
 554                 g_string_free(clock_class->description, TRUE);
 555         }
 556
 557         g_free(clock_class);
 558 }
 559
 560 static
 561 void bt_ctf_clock_value_destroy(struct bt_object *obj)
 562 {
 563         struct bt_ctf_clock_value *value;
 564
 565         BT_LOGD("Destroying clock value: addr=%p", obj);
 566
 567         if (!obj) {
 568                 return;
 569         }
 570
 571         value = container_of(obj, struct bt_ctf_clock_value, base);
 572         bt_put(value->clock_class);
 573         g_free(value);
 574 }
 575
 576 struct bt_ctf_clock_value *bt_ctf_clock_value_create(
 577                 struct bt_ctf_clock_class *clock_class, uint64_t value)
 578 {
 579         struct bt_ctf_clock_value *ret = NULL;
 580
 581         BT_LOGD("Creating clock value object: clock-class-addr=%p, "
 582                 "value=%" PRIu64, clock_class, value);
 583
 584         if (!clock_class) {
 585                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 586                 goto end;
 587         }
 588
 589         ret = g_new0(struct bt_ctf_clock_value, 1);
 590         if (!ret) {
 591                 BT_LOGE_STR("Failed to allocate one clock value.");
 592                 goto end;
 593         }
 594
 595         bt_object_init(ret, bt_ctf_clock_value_destroy);
 596         ret->clock_class = bt_get(clock_class);
 597         ret->value = value;
 598         BT_LOGD("Created clock value object: addr=%p", ret);
 599 end:
 600         return ret;
 601 }
 602
 603 int bt_ctf_clock_value_get_value(
 604                 struct bt_ctf_clock_value *clock_value, uint64_t *raw_value)
 605 {
 606         int ret = 0;
 607
 608         if (!clock_value || !raw_value) {
 609                 BT_LOGW("Invalid parameter: clock value or raw value is NULL: "
 610                         "clock-value-addr=%p, raw-value-addr=%p",
 611                         clock_value, raw_value);
 612                 ret = -1;
 613                 goto end;
 614         }
 615
 616         *raw_value = clock_value->value;
 617 end:
 618         return ret;
 619 }
 620
 621 int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
 622                 int64_t *ret_value_ns)
 623 {
 624         int ret = 0;
 625         int64_t ns;
 626
 627         if (!value || !ret_value_ns) {
 628                 BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: "
 629                         "clock-value-addr=%p, ret-value-addr=%p",
 630                         value, ret_value_ns);
 631                 ret = -1;
 632                 goto end;
 633         }
 634
 635         /* Initialize nanosecond timestamp to clock's offset in seconds. */
 636         ns = value->clock_class->offset_s * (int64_t) 1000000000;
 637
 638         /* Add offset in cycles, converted to nanoseconds. */
 639         ns += ns_from_value(value->clock_class->frequency,
 640                         value->clock_class->offset);
 641
 642         /* Add given value, converter to nanoseconds. */
 643         ns += ns_from_value(value->clock_class->frequency, value->value);
 644
 645         *ret_value_ns = ns;
 646 end:
 647         return ret;
 648 }
 649
 650 struct bt_ctf_clock_class *bt_ctf_clock_value_get_class(
 651                 struct bt_ctf_clock_value *clock_value)
 652 {
 653         struct bt_ctf_clock_class *clock_class = NULL;
 654
 655         if (!clock_value) {
 656                 BT_LOGW_STR("Invalid parameter: clock value is NULL.");
 657                 goto end;
 658         }
 659
 660         clock_class = bt_get(clock_value->clock_class);
 661
 662 end:
 663         return clock_class;
 664 }