formats/ctf/ir/clock.c

   1 /*
   2  * clock.c
   3  *
   4  * Babeltrace CTF IR - Clock
   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-internal.h>
  30 #include <babeltrace/ctf-ir/utils.h>
  31 #include <babeltrace/ref.h>
  32 #include <babeltrace/ctf-writer/writer-internal.h>
  33 #include <babeltrace/object-internal.h>
  34 #include <babeltrace/compiler.h>
  35 #include <inttypes.h>
  36
  37 static
  38 void bt_ctf_clock_destroy(struct bt_object *obj);
  39
  40 BT_HIDDEN
  41 bool bt_ctf_clock_is_valid(struct bt_ctf_clock *clock)
  42 {
  43         return clock && clock->name;
  44 }
  45
  46 int bt_ctf_clock_set_name(struct bt_ctf_clock *clock,
  47                 const char *name)
  48 {
  49         int ret = 0;
  50
  51         if (!clock || clock->frozen) {
  52                 ret = -1;
  53                 goto end;
  54         }
  55
  56         if (bt_ctf_validate_identifier(name)) {
  57                 ret = -1;
  58                 goto end;
  59         }
  60
  61         if (clock->name) {
  62                 g_string_assign(clock->name, name);
  63         } else {
  64                 clock->name = g_string_new(name);
  65                 if (!clock->name) {
  66                         ret = -1;
  67                         goto end;
  68                 }
  69         }
  70
  71 end:
  72         return ret;
  73 }
  74
  75 struct bt_ctf_clock *bt_ctf_clock_create(const char *name)
  76 {
  77         int ret;
  78         struct bt_ctf_clock *clock = g_new0(struct bt_ctf_clock, 1);
  79
  80         if (!clock) {
  81                 goto error;
  82         }
  83
  84         clock->precision = 1;
  85         clock->frequency = 1000000000;
  86         bt_object_init(clock, bt_ctf_clock_destroy);
  87
  88         if (name) {
  89                 ret = bt_ctf_clock_set_name(clock, name);
  90                 if (ret) {
  91                         goto error;
  92                 }
  93         }
  94
  95         ret = bt_uuid_generate(clock->uuid);
  96         if (ret) {
  97                 goto error;
  98         }
  99
 100         /*
 101          * For backward compatibility reasons, a fresh clock can have
 102          * a value because it could be added to a trace created by a
 103          * CTF writer. As soon as this clock is added to a non-writer
 104          * trace, then its value/time functions will be disabled.
 105          */
 106         clock->has_value = 1;
 107         clock->uuid_set = 1;
 108         return clock;
 109 error:
 110         BT_PUT(clock);
 111         return clock;
 112 }
 113
 114 const char *bt_ctf_clock_get_name(struct bt_ctf_clock *clock)
 115 {
 116         const char *ret = NULL;
 117
 118         if (!clock) {
 119                 goto end;
 120         }
 121
 122         if (clock->name) {
 123                 ret = clock->name->str;
 124         }
 125
 126 end:
 127         return ret;
 128 }
 129
 130 const char *bt_ctf_clock_get_description(struct bt_ctf_clock *clock)
 131 {
 132         const char *ret = NULL;
 133
 134         if (!clock) {
 135                 goto end;
 136         }
 137
 138         if (clock->description) {
 139                 ret = clock->description->str;
 140         }
 141 end:
 142         return ret;
 143 }
 144
 145 int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc)
 146 {
 147         int ret = 0;
 148
 149         if (!clock || !desc || clock->frozen) {
 150                 ret = -1;
 151                 goto end;
 152         }
 153
 154         clock->description = g_string_new(desc);
 155         ret = clock->description ? 0 : -1;
 156 end:
 157         return ret;
 158 }
 159
 160 uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock)
 161 {
 162         uint64_t ret = -1ULL;
 163
 164         if (!clock) {
 165                 goto end;
 166         }
 167
 168         ret = clock->frequency;
 169 end:
 170         return ret;
 171 }
 172
 173 int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq)
 174 {
 175         int ret = 0;
 176
 177         if (!clock || clock->frozen) {
 178                 ret = -1;
 179                 goto end;
 180         }
 181
 182         clock->frequency = freq;
 183 end:
 184         return ret;
 185 }
 186
 187 uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock)
 188 {
 189         uint64_t ret = -1ULL;
 190
 191         if (!clock) {
 192                 goto end;
 193         }
 194
 195         ret = clock->precision;
 196 end:
 197         return ret;
 198 }
 199
 200 int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision)
 201 {
 202         int ret = 0;
 203
 204         if (!clock || clock->frozen) {
 205                 ret = -1;
 206                 goto end;
 207         }
 208
 209         clock->precision = precision;
 210 end:
 211         return ret;
 212 }
 213
 214 int bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock, int64_t *offset_s)
 215 {
 216         int ret = 0;
 217
 218         if (!clock || !offset_s) {
 219                 ret = -1;
 220                 goto end;
 221         }
 222
 223         *offset_s = clock->offset_s;
 224 end:
 225         return ret;
 226 }
 227
 228 int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, int64_t offset_s)
 229 {
 230         int ret = 0;
 231
 232         if (!clock || clock->frozen) {
 233                 ret = -1;
 234                 goto end;
 235         }
 236
 237         clock->offset_s = offset_s;
 238 end:
 239         return ret;
 240 }
 241
 242 int bt_ctf_clock_get_offset(struct bt_ctf_clock *clock, int64_t *offset)
 243 {
 244         int ret = 0;
 245
 246         if (!clock || !offset) {
 247                 ret = -1;
 248                 goto end;
 249         }
 250
 251         *offset = clock->offset;
 252 end:
 253         return ret;
 254 }
 255
 256 int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, int64_t offset)
 257 {
 258         int ret = 0;
 259
 260         if (!clock || clock->frozen) {
 261                 ret = -1;
 262                 goto end;
 263         }
 264
 265         clock->offset = offset;
 266 end:
 267         return ret;
 268 }
 269
 270 int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock)
 271 {
 272         int ret = -1;
 273
 274         if (!clock) {
 275                 goto end;
 276         }
 277
 278         ret = clock->absolute;
 279 end:
 280         return ret;
 281 }
 282
 283 int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute)
 284 {
 285         int ret = 0;
 286
 287         if (!clock || clock->frozen) {
 288                 ret = -1;
 289                 goto end;
 290         }
 291
 292         clock->absolute = !!is_absolute;
 293 end:
 294         return ret;
 295 }
 296
 297 const unsigned char *bt_ctf_clock_get_uuid(struct bt_ctf_clock *clock)
 298 {
 299         const unsigned char *ret;
 300
 301         if (!clock || !clock->uuid_set) {
 302                 ret = NULL;
 303                 goto end;
 304         }
 305
 306         ret = clock->uuid;
 307 end:
 308         return ret;
 309 }
 310
 311 int bt_ctf_clock_set_uuid(struct bt_ctf_clock *clock, const unsigned char *uuid)
 312 {
 313         int ret = 0;
 314
 315         if (!clock || !uuid || clock->frozen) {
 316                 ret = -1;
 317                 goto end;
 318         }
 319
 320         memcpy(clock->uuid, uuid, sizeof(uuid_t));
 321         clock->uuid_set = 1;
 322 end:
 323         return ret;
 324 }
 325
 326 uint64_t ns_from_value(uint64_t frequency, uint64_t value)
 327 {
 328         uint64_t ns;
 329
 330         if (frequency == 1000000000) {
 331                 ns = value;
 332         } else {
 333                 ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
 334         }
 335
 336         return ns;
 337 }
 338
 339 int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, int64_t time)
 340 {
 341         int ret = 0;
 342         int64_t value;
 343
 344         /* Timestamps are strictly monotonic */
 345         if (!clock) {
 346                 ret = -1;
 347                 goto end;
 348         }
 349
 350
 351         if (!clock->has_value) {
 352                 /*
 353                  * Clock belongs to a non-writer mode trace and thus
 354                  * this function is disabled.
 355                  */
 356                 ret = -1;
 357                 goto end;
 358         }
 359
 360         /* Common case where cycles are actually nanoseconds */
 361         if (clock->frequency == 1000000000) {
 362                 value = time;
 363         } else {
 364                 value = (uint64_t) (((double) time *
 365                         (double) clock->frequency) / 1e9);
 366         }
 367
 368         if (clock->value > value) {
 369                 /* Timestamps must be strictly monotonic. */
 370                 ret = -1;
 371                 goto end;
 372         }
 373
 374         clock->value = value;
 375 end:
 376         return ret;
 377 }
 378
 379 void bt_ctf_clock_get(struct bt_ctf_clock *clock)
 380 {
 381         bt_get(clock);
 382 }
 383
 384 void bt_ctf_clock_put(struct bt_ctf_clock *clock)
 385 {
 386         bt_put(clock);
 387 }
 388
 389 BT_HIDDEN
 390 void bt_ctf_clock_freeze(struct bt_ctf_clock *clock)
 391 {
 392         if (!clock) {
 393                 return;
 394         }
 395
 396         clock->frozen = 1;
 397 }
 398
 399 BT_HIDDEN
 400 void bt_ctf_clock_serialize(struct bt_ctf_clock *clock,
 401                 struct metadata_context *context)
 402 {
 403         unsigned char *uuid;
 404
 405         if (!clock || !context) {
 406                 return;
 407         }
 408
 409         uuid = clock->uuid;
 410         g_string_append(context->string, "clock {\n");
 411         g_string_append_printf(context->string, "\tname = %s;\n",
 412                 clock->name->str);
 413         g_string_append_printf(context->string,
 414                 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 415                 uuid[0], uuid[1], uuid[2], uuid[3],
 416                 uuid[4], uuid[5], uuid[6], uuid[7],
 417                 uuid[8], uuid[9], uuid[10], uuid[11],
 418                 uuid[12], uuid[13], uuid[14], uuid[15]);
 419         if (clock->description) {
 420                 g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
 421                         clock->description->str);
 422         }
 423
 424         g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
 425                 clock->frequency);
 426         g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
 427                 clock->precision);
 428         g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
 429                 clock->offset_s);
 430         g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
 431                 clock->offset);
 432         g_string_append_printf(context->string, "\tabsolute = %s;\n",
 433                 clock->absolute ? "TRUE" : "FALSE");
 434         g_string_append(context->string, "};\n\n");
 435 }
 436
 437 BT_HIDDEN
 438 int bt_ctf_clock_get_value(struct bt_ctf_clock *clock, uint64_t *value)
 439 {
 440         int ret = 0;
 441
 442         if (!clock || !value) {
 443                 ret = -1;
 444                 goto end;
 445         }
 446
 447         *value = clock->value;
 448 end:
 449         return ret;
 450 }
 451
 452 static
 453 void bt_ctf_clock_destroy(struct bt_object *obj)
 454 {
 455         struct bt_ctf_clock *clock;
 456
 457         clock = container_of(obj, struct bt_ctf_clock, base);
 458         if (clock->name) {
 459                 g_string_free(clock->name, TRUE);
 460         }
 461
 462         if (clock->description) {
 463                 g_string_free(clock->description, TRUE);
 464         }
 465
 466         g_free(clock);
 467 }
 468
 469 static
 470 void bt_ctf_clock_value_destroy(struct bt_object *obj)
 471 {
 472         struct bt_ctf_clock_value *value;
 473
 474         if (!obj) {
 475                 return;
 476         }
 477
 478         value = container_of(obj, struct bt_ctf_clock_value, base);
 479         bt_put(value->clock_class);
 480         g_free(value);
 481 }
 482
 483 struct bt_ctf_clock_value *bt_ctf_clock_value_create(
 484                 struct bt_ctf_clock *clock, uint64_t value)
 485 {
 486         struct bt_ctf_clock_value *ret = NULL;
 487
 488         if (!clock) {
 489                 goto end;
 490         }
 491
 492         ret = g_new0(struct bt_ctf_clock_value, 1);
 493         if (!ret) {
 494                 goto end;
 495         }
 496
 497         bt_object_init(ret, bt_ctf_clock_value_destroy);
 498         ret->clock_class = bt_get(clock);
 499         ret->value = value;
 500 end:
 501         return ret;
 502 }
 503
 504 int bt_ctf_clock_value_get_value(
 505                 struct bt_ctf_clock_value *clock_value, uint64_t *raw_value)
 506 {
 507         int ret = 0;
 508
 509         if (!clock_value || !raw_value) {
 510                 ret = -1;
 511                 goto end;
 512         }
 513
 514         *raw_value = clock_value->value;
 515 end:
 516         return ret;
 517 }
 518
 519 int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
 520                 int64_t *ret_value_ns)
 521 {
 522         int ret = 0;
 523         int64_t ns;
 524
 525         if (!value || !ret_value_ns) {
 526                 ret = -1;
 527                 goto end;
 528         }
 529
 530         /* Initialize nanosecond timestamp to clock's offset in seconds. */
 531         ns = value->clock_class->offset_s * 1000000000;
 532
 533         /* Add offset in cycles, converted to nanoseconds. */
 534         ns += ns_from_value(value->clock_class->frequency,
 535                         value->clock_class->offset);
 536
 537         /* Add given value, converter to nanoseconds. */
 538         ns += ns_from_value(value->clock_class->frequency, value->value);
 539
 540         *ret_value_ns = ns;
 541 end:
 542         return ret;
 543 }