src/ctf-writer/clock-class.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  *
   6  * Babeltrace CTF writer - Clock class
   7  */
   8
   9 #define BT_LOG_TAG "CTF-WRITER/CLOCK-CLASS"
  10 #include "logging.h"
  11
  12 #include "common/uuid.h"
  13 #include <babeltrace2-ctf-writer/utils.h>
  14 #include <babeltrace2-ctf-writer/object.h>
  15 #include "compat/compiler.h"
  16 #include "compat/string.h"
  17 #include <stdbool.h>
  18 #include <inttypes.h>
  19 #include "common/assert.h"
  20
  21 #include "assert-pre.h"
  22 #include "clock-class.h"
  23 #include "object.h"
  24
  25 static
  26 void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj);
  27
  28 bt_ctf_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
  29 {
  30         return clock_class && clock_class->name;
  31 }
  32
  33 int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class,
  34                 const char *name)
  35 {
  36         int ret = 0;
  37
  38         if (!clock_class) {
  39                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
  40                 ret = -1;
  41                 goto end;
  42         }
  43
  44         if (clock_class->frozen) {
  45                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
  46                         clock_class, bt_ctf_clock_class_get_name(clock_class));
  47                 ret = -1;
  48                 goto end;
  49         }
  50
  51         if (!bt_ctf_identifier_is_valid(name)) {
  52                 BT_LOGW("Clock class's name is not a valid CTF identifier: "
  53                         "addr=%p, name=\"%s\"",
  54                         clock_class, name);
  55                 ret = -1;
  56                 goto end;
  57         }
  58
  59         if (clock_class->name) {
  60                 g_string_assign(clock_class->name, name);
  61         } else {
  62                 clock_class->name = g_string_new(name);
  63                 if (!clock_class->name) {
  64                         BT_LOGE_STR("Failed to allocate a GString.");
  65                         ret = -1;
  66                         goto end;
  67                 }
  68         }
  69
  70         BT_LOGT("Set clock class's name: addr=%p, name=\"%s\"",
  71                 clock_class, name);
  72
  73 end:
  74         return ret;
  75 }
  76
  77 static
  78 bool validate_freq(struct bt_ctf_clock_class *clock_class,
  79                 const char *name, uint64_t freq)
  80 {
  81         bool is_valid = true;
  82
  83         if (freq == -1ULL || freq == 0) {
  84                 BT_LOGW("Invalid parameter: frequency is invalid: "
  85                         "addr=%p, name=\"%s\", freq=%" PRIu64,
  86                         clock_class, name, freq);
  87                 is_valid = false;
  88                 goto end;
  89         }
  90
  91 end:
  92         return is_valid;
  93 }
  94
  95 struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name,
  96                 uint64_t freq)
  97 {
  98         int ret;
  99         struct bt_ctf_clock_class *clock_class = NULL;
 100
 101         BT_LOGD("Creating default clock class object: name=\"%s\"",
 102                 name);
 103
 104         if (!validate_freq(NULL, name, freq)) {
 105                 /* validate_freq() logs errors */
 106                 goto error;
 107         }
 108
 109         clock_class = g_new0(struct bt_ctf_clock_class, 1);
 110         if (!clock_class) {
 111                 BT_LOGE_STR("Failed to allocate one clock class.");
 112                 goto error;
 113         }
 114
 115         clock_class->precision = 1;
 116         clock_class->frequency = freq;
 117         bt_ctf_object_init_shared(&clock_class->base, bt_ctf_clock_class_destroy);
 118
 119         if (name) {
 120                 ret = bt_ctf_clock_class_set_name(clock_class, name);
 121                 if (ret) {
 122                         /* bt_ctf_clock_class_set_name() logs errors */
 123                         goto error;
 124                 }
 125         }
 126
 127         BT_LOGD("Created clock class object: addr=%p, name=\"%s\"",
 128                 clock_class, name);
 129         return clock_class;
 130 error:
 131         BT_CTF_OBJECT_PUT_REF_AND_RESET(clock_class);
 132         return clock_class;
 133 }
 134
 135 const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class)
 136 {
 137         const char *ret = NULL;
 138
 139         if (!clock_class) {
 140                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 141                 goto end;
 142         }
 143
 144         if (clock_class->name) {
 145                 ret = clock_class->name->str;
 146         }
 147
 148 end:
 149         return ret;
 150 }
 151
 152 const char *bt_ctf_clock_class_get_description(
 153                 struct bt_ctf_clock_class *clock_class)
 154 {
 155         const char *ret = NULL;
 156
 157         if (!clock_class) {
 158                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 159                 goto end;
 160         }
 161
 162         if (clock_class->description) {
 163                 ret = clock_class->description->str;
 164         }
 165 end:
 166         return ret;
 167 }
 168
 169 int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
 170                 const char *desc)
 171 {
 172         int ret = 0;
 173
 174         if (!clock_class || !desc) {
 175                 BT_LOGW("Invalid parameter: clock class or description is NULL: "
 176                         "clock-class-addr=%p, name=\"%s\", desc-addr=%p",
 177                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 178                         desc);
 179                 ret = -1;
 180                 goto end;
 181         }
 182
 183         if (clock_class->frozen) {
 184                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 185                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 186                 ret = -1;
 187                 goto end;
 188         }
 189
 190         clock_class->description = g_string_new(desc);
 191         ret = clock_class->description ? 0 : -1;
 192         BT_LOGT("Set clock class's description: addr=%p, "
 193                 "name=\"%s\", desc=\"%s\"",
 194                 clock_class, bt_ctf_clock_class_get_name(clock_class), desc);
 195 end:
 196         return ret;
 197 }
 198
 199 uint64_t bt_ctf_clock_class_get_frequency(
 200                 struct bt_ctf_clock_class *clock_class)
 201 {
 202         uint64_t ret = -1ULL;
 203
 204         if (!clock_class) {
 205                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 206                 goto end;
 207         }
 208
 209         ret = clock_class->frequency;
 210 end:
 211         return ret;
 212 }
 213
 214 int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
 215                 uint64_t freq)
 216 {
 217         int ret = 0;
 218
 219         if (!clock_class) {
 220                 BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
 221                         "addr=%p, name=\"%s\"",
 222                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 223                 ret = -1;
 224                 goto end;
 225         }
 226
 227         if (!validate_freq(clock_class, bt_ctf_clock_class_get_name(clock_class),
 228                         freq)) {
 229                 /* validate_freq() logs errors */
 230                 goto end;
 231         }
 232
 233         if (clock_class->frozen) {
 234                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 235                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 236                 ret = -1;
 237                 goto end;
 238         }
 239
 240         clock_class->frequency = freq;
 241         BT_LOGT("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64,
 242                 clock_class, bt_ctf_clock_class_get_name(clock_class), freq);
 243 end:
 244         return ret;
 245 }
 246
 247 uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
 248 {
 249         uint64_t ret = -1ULL;
 250
 251         if (!clock_class) {
 252                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 253                 goto end;
 254         }
 255
 256         ret = clock_class->precision;
 257 end:
 258         return ret;
 259 }
 260
 261 int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
 262                 uint64_t precision)
 263 {
 264         int ret = 0;
 265
 266         if (!clock_class || precision == -1ULL) {
 267                 BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
 268                         "addr=%p, name=\"%s\", precision=%" PRIu64,
 269                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 270                         precision);
 271                 ret = -1;
 272                 goto end;
 273         }
 274
 275         if (clock_class->frozen) {
 276                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 277                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 278                 ret = -1;
 279                 goto end;
 280         }
 281
 282         clock_class->precision = precision;
 283         BT_LOGT("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64,
 284                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 285                 precision);
 286 end:
 287         return ret;
 288 }
 289
 290 int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
 291                 int64_t *offset_s)
 292 {
 293         int ret = 0;
 294
 295         if (!clock_class || !offset_s) {
 296                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 297                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 298                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 299                         offset_s);
 300                 ret = -1;
 301                 goto end;
 302         }
 303
 304         *offset_s = clock_class->offset_s;
 305 end:
 306         return ret;
 307 }
 308
 309 int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
 310                 int64_t offset_s)
 311 {
 312         int ret = 0;
 313
 314         if (!clock_class) {
 315                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 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_ctf_clock_class_get_name(clock_class));
 323                 ret = -1;
 324                 goto end;
 325         }
 326
 327         clock_class->offset_s = offset_s;
 328         BT_LOGT("Set clock class's offset (seconds): "
 329                 "addr=%p, name=\"%s\", offset-s=%" PRId64,
 330                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 331                 offset_s);
 332 end:
 333         return ret;
 334 }
 335
 336 int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
 337                 int64_t *offset)
 338 {
 339         int ret = 0;
 340
 341         if (!clock_class || !offset) {
 342                 BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
 343                         "clock-class-addr=%p, name=\"%s\", offset-addr=%p",
 344                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 345                         offset);
 346                 ret = -1;
 347                 goto end;
 348         }
 349
 350         *offset = clock_class->offset;
 351 end:
 352         return ret;
 353 }
 354
 355 int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
 356                 int64_t offset)
 357 {
 358         int ret = 0;
 359
 360         if (!clock_class) {
 361                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 362                 ret = -1;
 363                 goto end;
 364         }
 365
 366         if (clock_class->frozen) {
 367                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 368                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 369                 ret = -1;
 370                 goto end;
 371         }
 372
 373         clock_class->offset = offset;
 374         BT_LOGT("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64,
 375                 clock_class, bt_ctf_clock_class_get_name(clock_class), offset);
 376 end:
 377         return ret;
 378 }
 379
 380 bt_ctf_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
 381 {
 382         int ret = -1;
 383
 384         if (!clock_class) {
 385                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 386                 goto end;
 387         }
 388
 389         ret = clock_class->absolute;
 390 end:
 391         return ret;
 392 }
 393
 394 int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
 395                 bt_ctf_bool is_absolute)
 396 {
 397         int ret = 0;
 398
 399         if (!clock_class) {
 400                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 401                 ret = -1;
 402                 goto end;
 403         }
 404
 405         if (clock_class->frozen) {
 406                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 407                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 408                 ret = -1;
 409                 goto end;
 410         }
 411
 412         clock_class->absolute = !!is_absolute;
 413         BT_LOGT("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d",
 414                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 415                 is_absolute);
 416 end:
 417         return ret;
 418 }
 419
 420 const uint8_t *bt_ctf_clock_class_get_uuid(
 421                 struct bt_ctf_clock_class *clock_class)
 422 {
 423         const uint8_t *ret;
 424
 425         if (!clock_class) {
 426                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
 427                 ret = NULL;
 428                 goto end;
 429         }
 430
 431         if (!clock_class->uuid_set) {
 432                 BT_LOGT("Clock class's UUID is not set: addr=%p, name=\"%s\"",
 433                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 434                 ret = NULL;
 435                 goto end;
 436         }
 437
 438         ret = clock_class->uuid;
 439 end:
 440         return ret;
 441 }
 442
 443 int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
 444                 const uint8_t *uuid)
 445 {
 446         int ret = 0;
 447
 448         if (!clock_class || !uuid) {
 449                 BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
 450                         "clock-class-addr=%p, name=\"%s\", uuid-addr=%p",
 451                         clock_class, bt_ctf_clock_class_get_name(clock_class),
 452                         uuid);
 453                 ret = -1;
 454                 goto end;
 455         }
 456
 457         if (clock_class->frozen) {
 458                 BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
 459                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 460                 ret = -1;
 461                 goto end;
 462         }
 463
 464         bt_uuid_copy(clock_class->uuid, uuid);
 465         clock_class->uuid_set = 1;
 466         BT_LOGT("Set clock class's UUID: addr=%p, name=\"%s\", uuid=\"" BT_UUID_FMT "\"",
 467                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 468                 BT_UUID_FMT_VALUES(uuid));
 469 end:
 470         return ret;
 471 }
 472
 473 void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
 474 {
 475         if (!clock_class || clock_class->frozen) {
 476                 return;
 477         }
 478
 479         BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"",
 480                 clock_class, bt_ctf_clock_class_get_name(clock_class));
 481         clock_class->frozen = 1;
 482 }
 483
 484 static
 485 void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj)
 486 {
 487         struct bt_ctf_clock_class *clock_class;
 488
 489         clock_class = container_of(obj, struct bt_ctf_clock_class, base);
 490         BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"",
 491                 obj, bt_ctf_clock_class_get_name(clock_class));
 492
 493         if (clock_class->name) {
 494                 g_string_free(clock_class->name, TRUE);
 495         }
 496
 497         if (clock_class->description) {
 498                 g_string_free(clock_class->description, TRUE);
 499         }
 500
 501         g_free(clock_class);
 502 }
 503
 504 int bt_ctf_clock_class_compare(struct bt_ctf_clock_class *clock_class_a,
 505                 struct bt_ctf_clock_class *clock_class_b)
 506 {
 507         int ret = 1;
 508         BT_ASSERT_DBG(clock_class_a);
 509         BT_ASSERT_DBG(clock_class_b);
 510
 511         /* Name */
 512         if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) {
 513                 BT_LOGT("Clock classes differ: different names: "
 514                         "cc-a-name=\"%s\", cc-b-name=\"%s\"",
 515                         clock_class_a->name->str,
 516                         clock_class_b->name->str);
 517                 goto end;
 518         }
 519
 520         /* Description */
 521         if (clock_class_a->description) {
 522                 if (!clock_class_b->description) {
 523                         BT_LOGT_STR("Clock classes differ: clock class A has a "
 524                                 "description, but clock class B does not.");
 525                         goto end;
 526                 }
 527
 528                 if (strcmp(clock_class_a->name->str, clock_class_b->name->str)
 529                                 != 0) {
 530                         BT_LOGT("Clock classes differ: different descriptions: "
 531                                 "cc-a-descr=\"%s\", cc-b-descr=\"%s\"",
 532                                 clock_class_a->description->str,
 533                                 clock_class_b->description->str);
 534                         goto end;
 535                 }
 536         } else {
 537                 if (clock_class_b->description) {
 538                         BT_LOGT_STR("Clock classes differ: clock class A has "
 539                                 "no description, but clock class B has one.");
 540                         goto end;
 541                 }
 542         }
 543
 544         /* Frequency */
 545         if (clock_class_a->frequency != clock_class_b->frequency) {
 546                 BT_LOGT("Clock classes differ: different frequencies: "
 547                         "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
 548                         clock_class_a->frequency,
 549                         clock_class_b->frequency);
 550                 goto end;
 551         }
 552
 553         /* Precision */
 554         if (clock_class_a->precision != clock_class_b->precision) {
 555                 BT_LOGT("Clock classes differ: different precisions: "
 556                         "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
 557                         clock_class_a->precision,
 558                         clock_class_b->precision);
 559                 goto end;
 560         }
 561
 562         /* Offset (seconds) */
 563         if (clock_class_a->offset_s != clock_class_b->offset_s) {
 564                 BT_LOGT("Clock classes differ: different offsets (seconds): "
 565                         "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
 566                         clock_class_a->offset_s,
 567                         clock_class_b->offset_s);
 568                 goto end;
 569         }
 570
 571         /* Offset (cycles) */
 572         if (clock_class_a->offset != clock_class_b->offset) {
 573                 BT_LOGT("Clock classes differ: different offsets (cycles): "
 574                         "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
 575                         clock_class_a->offset,
 576                         clock_class_b->offset);
 577                 goto end;
 578         }
 579
 580         /* UUIDs */
 581         if (clock_class_a->uuid_set) {
 582                 if (!clock_class_b->uuid_set) {
 583                         BT_LOGT_STR("Clock classes differ: clock class A has a "
 584                                 "UUID, but clock class B does not.");
 585                         goto end;
 586                 }
 587
 588                 if (bt_uuid_compare(clock_class_a->uuid, clock_class_b->uuid) != 0) {
 589                         BT_LOGT("Clock classes differ: different UUIDs: "
 590                                 "cc-a-uuid=\"" BT_UUID_FMT "\", "
 591                                 "cc-b-uuid=\"" BT_UUID_FMT "\"",
 592                                 BT_UUID_FMT_VALUES(clock_class_a->uuid),
 593                                 BT_UUID_FMT_VALUES(clock_class_b->uuid));
 594                         goto end;
 595                 }
 596         } else {
 597                 if (clock_class_b->uuid_set) {
 598                         BT_LOGT_STR("Clock classes differ: clock class A has "
 599                                 "no UUID, but clock class B has one.");
 600                         goto end;
 601                 }
 602         }
 603
 604         /* Absolute */
 605         if (!!clock_class_a->absolute != !!clock_class_b->absolute) {
 606                 BT_LOGT("Clock classes differ: one is absolute, the other "
 607                         "is not: cc-a-is-absolute=%d, cc-b-is-absolute=%d",
 608                         !!clock_class_a->absolute,
 609                         !!clock_class_b->absolute);
 610                 goto end;
 611         }
 612
 613         /* Equal */
 614         ret = 0;
 615
 616 end:
 617         return ret;
 618 }