src/lib/trace-ir/trace.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   5  * Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  */
   7
   8 #define BT_LOG_TAG "LIB/TRACE"
   9 #include "lib/logging.h"
  10
  11 #include "lib/assert-cond.h"
  12 #include <babeltrace2/trace-ir/trace.h>
  13 #include <babeltrace2/trace-ir/event-class.h>
  14 #include "compat/compiler.h"
  15 #include <babeltrace2/value.h>
  16 #include "lib/value.h"
  17 #include <babeltrace2/types.h>
  18 #include "compat/endian.h"
  19 #include "common/assert.h"
  20 #include "compat/glib.h"
  21 #include <inttypes.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26
  27 #include "attributes.h"
  28 #include "stream-class.h"
  29 #include "stream.h"
  30 #include "trace-class.h"
  31 #include "trace.h"
  32 #include "lib/value.h"
  33 #include "lib/func-status.h"
  34
  35 struct bt_trace_destruction_listener_elem {
  36         bt_trace_destruction_listener_func func;
  37         void *data;
  38 };
  39
  40 #define BT_ASSERT_PRE_DEV_TRACE_HOT(_trace)                             \
  41         BT_ASSERT_PRE_DEV_HOT("trace", (_trace), "Trace", ": %!+t", (_trace))
  42
  43 #define DESTRUCTION_LISTENER_FUNC_NAME                                  \
  44         "bt_trace_class_destruction_listener_func"
  45
  46 static
  47 void destroy_trace(struct bt_object *obj)
  48 {
  49         struct bt_trace *trace = (void *) obj;
  50
  51         BT_LIB_LOGD("Destroying trace object: %!+t", trace);
  52         BT_OBJECT_PUT_REF_AND_RESET(trace->user_attributes);
  53
  54         /*
  55          * Call destruction listener functions so that everything else
  56          * still exists in the trace.
  57          */
  58         if (trace->destruction_listeners) {
  59                 uint64_t i;
  60                 const struct bt_error *saved_error;
  61
  62                 BT_LIB_LOGD("Calling trace destruction listener(s): %!+t", trace);
  63
  64                 /*
  65                 * The trace's reference count is 0 if we're here. Increment
  66                 * it to avoid a double-destroy (possibly infinitely recursive).
  67                 * This could happen for example if a destruction listener did
  68                 * bt_object_get_ref() (or anything that causes
  69                 * bt_object_get_ref() to be called) on the trace (ref.
  70                 * count goes from 0 to 1), and then bt_object_put_ref(): the
  71                 * reference count would go from 1 to 0 again and this function
  72                 * would be called again.
  73                 */
  74                 trace->base.ref_count++;
  75
  76                 saved_error = bt_current_thread_take_error();
  77
  78                 /* Call all the trace destruction listeners */
  79                 for (i = 0; i < trace->destruction_listeners->len; i++) {
  80                         struct bt_trace_destruction_listener_elem elem =
  81                                 bt_g_array_index(trace->destruction_listeners,
  82                                         struct bt_trace_destruction_listener_elem, i);
  83
  84                         if (elem.func) {
  85                                 elem.func(trace, elem.data);
  86                                 BT_ASSERT_POST_NO_ERROR(
  87                                         DESTRUCTION_LISTENER_FUNC_NAME);
  88                         }
  89
  90                         /*
  91                          * The destruction listener should not have kept a
  92                          * reference to the trace.
  93                          */
  94                         BT_ASSERT_POST(DESTRUCTION_LISTENER_FUNC_NAME,
  95                                 "trace-reference-count-not-changed",
  96                                 trace->base.ref_count == 1,
  97                                 "Destruction listener kept a reference to the trace being destroyed: %![trace-]+t",
  98                                 trace);
  99                 }
 100                 g_array_free(trace->destruction_listeners, TRUE);
 101                 trace->destruction_listeners = NULL;
 102
 103                 if (saved_error) {
 104                         BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(saved_error);
 105                 }
 106         }
 107
 108         if (trace->name.str) {
 109                 g_string_free(trace->name.str, TRUE);
 110                 trace->name.str = NULL;
 111                 trace->name.value = NULL;
 112         }
 113
 114         if (trace->environment) {
 115                 BT_LOGD_STR("Destroying environment attributes.");
 116                 bt_attributes_destroy(trace->environment);
 117                 trace->environment = NULL;
 118         }
 119
 120         if (trace->streams) {
 121                 BT_LOGD_STR("Destroying streams.");
 122                 g_ptr_array_free(trace->streams, TRUE);
 123                 trace->streams = NULL;
 124         }
 125
 126         if (trace->stream_classes_stream_count) {
 127                 g_hash_table_destroy(trace->stream_classes_stream_count);
 128                 trace->stream_classes_stream_count = NULL;
 129         }
 130
 131         BT_LOGD_STR("Putting trace's class.");
 132         bt_object_put_ref(trace->class);
 133         trace->class = NULL;
 134         g_free(trace);
 135 }
 136
 137 BT_EXPORT
 138 struct bt_trace *bt_trace_create(struct bt_trace_class *tc)
 139 {
 140         struct bt_trace *trace = NULL;
 141
 142         BT_ASSERT_PRE_NO_ERROR();
 143
 144         BT_LIB_LOGD("Creating trace object: %![tc-]+T", tc);
 145         trace = g_new0(struct bt_trace, 1);
 146         if (!trace) {
 147                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one trace.");
 148                 goto error;
 149         }
 150
 151         bt_object_init_shared(&trace->base, destroy_trace);
 152         trace->user_attributes = bt_value_map_create();
 153         if (!trace->user_attributes) {
 154                 BT_LIB_LOGE_APPEND_CAUSE(
 155                         "Failed to create a map value object.");
 156                 goto error;
 157         }
 158
 159         trace->streams = g_ptr_array_new_with_free_func(
 160                 (GDestroyNotify) bt_object_try_spec_release);
 161         if (!trace->streams) {
 162                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray.");
 163                 goto error;
 164         }
 165
 166         trace->stream_classes_stream_count = g_hash_table_new(g_direct_hash,
 167                 g_direct_equal);
 168         if (!trace->stream_classes_stream_count) {
 169                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GHashTable.");
 170                 goto error;
 171         }
 172
 173         trace->name.str = g_string_new(NULL);
 174         if (!trace->name.str) {
 175                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GString.");
 176                 goto error;
 177         }
 178
 179         trace->environment = bt_attributes_create();
 180         if (!trace->environment) {
 181                 BT_LIB_LOGE_APPEND_CAUSE("Cannot create empty attributes object.");
 182                 goto error;
 183         }
 184
 185         trace->destruction_listeners = g_array_new(FALSE, TRUE,
 186                 sizeof(struct bt_trace_destruction_listener_elem));
 187         if (!trace->destruction_listeners) {
 188                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GArray.");
 189                 goto error;
 190         }
 191
 192         trace->class = tc;
 193         bt_object_get_ref_no_null_check(trace->class);
 194         BT_LIB_LOGD("Created trace object: %!+t", trace);
 195         goto end;
 196
 197 error:
 198         BT_OBJECT_PUT_REF_AND_RESET(trace);
 199
 200 end:
 201         return trace;
 202 }
 203
 204 BT_EXPORT
 205 const char *bt_trace_get_name(const struct bt_trace *trace)
 206 {
 207         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 208         return trace->name.value;
 209 }
 210
 211 BT_EXPORT
 212 enum bt_trace_set_name_status bt_trace_set_name(struct bt_trace *trace,
 213                 const char *name)
 214 {
 215         BT_ASSERT_PRE_NO_ERROR();
 216         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 217         BT_ASSERT_PRE_NAME_NON_NULL(name);
 218         BT_ASSERT_PRE_DEV_TRACE_HOT(trace);
 219         g_string_assign(trace->name.str, name);
 220         trace->name.value = trace->name.str->str;
 221         BT_LIB_LOGD("Set trace's name: %!+t", trace);
 222         return BT_FUNC_STATUS_OK;
 223 }
 224
 225 BT_EXPORT
 226 bt_uuid bt_trace_get_uuid(const struct bt_trace *trace)
 227 {
 228         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 229         return trace->uuid.value;
 230 }
 231
 232 BT_EXPORT
 233 void bt_trace_set_uuid(struct bt_trace *trace, bt_uuid uuid)
 234 {
 235         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 236         BT_ASSERT_PRE_UUID_NON_NULL(uuid);
 237         BT_ASSERT_PRE_DEV_TRACE_HOT(trace);
 238         bt_uuid_copy(trace->uuid.uuid, uuid);
 239         trace->uuid.value = trace->uuid.uuid;
 240         BT_LIB_LOGD("Set trace's UUID: %!+t", trace);
 241 }
 242
 243 static
 244 bool trace_has_environment_entry(const struct bt_trace *trace, const char *name)
 245 {
 246         BT_ASSERT(trace);
 247
 248         return bt_attributes_borrow_field_value_by_name(
 249                 trace->environment, name);
 250 }
 251
 252 static
 253 enum bt_trace_set_environment_entry_status set_environment_entry(
 254                 struct bt_trace *trace,
 255                 const char *name, struct bt_value *value)
 256 {
 257         int ret;
 258
 259         BT_ASSERT(trace);
 260         BT_ASSERT(name);
 261         BT_ASSERT(value);
 262         BT_ASSERT_PRE("not-frozen:trace",
 263                 !trace->frozen ||
 264                         !trace_has_environment_entry(trace, name),
 265                 "Trace is frozen: cannot replace environment entry: "
 266                 "%![trace-]+t, entry-name=\"%s\"", trace, name);
 267         ret = bt_attributes_set_field_value(trace->environment, name,
 268                 value);
 269         if (ret) {
 270                 ret = BT_FUNC_STATUS_MEMORY_ERROR;
 271                 BT_LIB_LOGE_APPEND_CAUSE(
 272                         "Cannot set trace's environment entry: "
 273                         "%![trace-]+t, entry-name=\"%s\"", trace, name);
 274         } else {
 275                 bt_value_freeze(value);
 276                 BT_LIB_LOGD("Set trace's environment entry: "
 277                         "%![trace-]+t, entry-name=\"%s\"", trace, name);
 278         }
 279
 280         return ret;
 281 }
 282
 283 BT_EXPORT
 284 enum bt_trace_set_environment_entry_status
 285 bt_trace_set_environment_entry_string(
 286                 struct bt_trace *trace, const char *name, const char *value)
 287 {
 288         int ret;
 289         struct bt_value *value_obj;
 290
 291         BT_ASSERT_PRE_NO_ERROR();
 292         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 293         BT_ASSERT_PRE_NAME_NON_NULL(name);
 294         BT_ASSERT_PRE_NON_NULL("value", value, "Value");
 295
 296         value_obj = bt_value_string_create_init(value);
 297         if (!value_obj) {
 298                 BT_LIB_LOGE_APPEND_CAUSE(
 299                         "Cannot create a string value object.");
 300                 ret = -1;
 301                 goto end;
 302         }
 303
 304         /* set_environment_entry() logs errors */
 305         ret = set_environment_entry(trace, name, value_obj);
 306
 307 end:
 308         bt_object_put_ref(value_obj);
 309         return ret;
 310 }
 311
 312 BT_EXPORT
 313 enum bt_trace_set_environment_entry_status
 314 bt_trace_set_environment_entry_integer(
 315                 struct bt_trace *trace, const char *name, int64_t value)
 316 {
 317         int ret;
 318         struct bt_value *value_obj;
 319
 320         BT_ASSERT_PRE_NO_ERROR();
 321         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 322         BT_ASSERT_PRE_NAME_NON_NULL(name);
 323
 324         value_obj = bt_value_integer_signed_create_init(value);
 325         if (!value_obj) {
 326                 BT_LIB_LOGE_APPEND_CAUSE(
 327                         "Cannot create an integer value object.");
 328                 ret = BT_FUNC_STATUS_MEMORY_ERROR;
 329                 goto end;
 330         }
 331
 332         /* set_environment_entry() logs errors */
 333         ret = set_environment_entry(trace, name, value_obj);
 334
 335 end:
 336         bt_object_put_ref(value_obj);
 337         return ret;
 338 }
 339
 340 BT_EXPORT
 341 uint64_t bt_trace_get_environment_entry_count(const struct bt_trace *trace)
 342 {
 343         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 344         return bt_attributes_get_count(trace->environment);
 345 }
 346
 347 BT_EXPORT
 348 void bt_trace_borrow_environment_entry_by_index_const(
 349                 const struct bt_trace *trace, uint64_t index,
 350                 const char **name, const struct bt_value **value)
 351 {
 352         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 353         BT_ASSERT_PRE_DEV_NAME_NON_NULL(name);
 354         BT_ASSERT_PRE_DEV_NON_NULL("value-object-output", value,
 355                 "Value object (output)");
 356         BT_ASSERT_PRE_DEV_VALID_INDEX(index,
 357                 bt_attributes_get_count(trace->environment));
 358         *value = bt_attributes_borrow_field_value(trace->environment, index);
 359         BT_ASSERT(*value);
 360         *name = bt_attributes_get_field_name(trace->environment, index);
 361         BT_ASSERT(*name);
 362 }
 363
 364 BT_EXPORT
 365 const struct bt_value *bt_trace_borrow_environment_entry_value_by_name_const(
 366                 const struct bt_trace *trace, const char *name)
 367 {
 368         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 369         BT_ASSERT_PRE_DEV_NAME_NON_NULL(name);
 370         return bt_attributes_borrow_field_value_by_name(trace->environment,
 371                 name);
 372 }
 373
 374 BT_EXPORT
 375 uint64_t bt_trace_get_stream_count(const struct bt_trace *trace)
 376 {
 377         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 378         return (uint64_t) trace->streams->len;
 379 }
 380
 381 BT_EXPORT
 382 struct bt_stream *bt_trace_borrow_stream_by_index(
 383                 struct bt_trace *trace, uint64_t index)
 384 {
 385         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 386         BT_ASSERT_PRE_DEV_VALID_INDEX(index, trace->streams->len);
 387         return g_ptr_array_index(trace->streams, index);
 388 }
 389
 390 BT_EXPORT
 391 const struct bt_stream *bt_trace_borrow_stream_by_index_const(
 392                 const struct bt_trace *trace, uint64_t index)
 393 {
 394         return bt_trace_borrow_stream_by_index((void *) trace, index);
 395 }
 396
 397 BT_EXPORT
 398 struct bt_stream *bt_trace_borrow_stream_by_id(struct bt_trace *trace,
 399                 uint64_t id)
 400 {
 401         struct bt_stream *stream = NULL;
 402         uint64_t i;
 403
 404         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 405
 406         for (i = 0; i < trace->streams->len; i++) {
 407                 struct bt_stream *stream_candidate =
 408                         g_ptr_array_index(trace->streams, i);
 409
 410                 if (stream_candidate->id == id) {
 411                         stream = stream_candidate;
 412                         goto end;
 413                 }
 414         }
 415
 416 end:
 417         return stream;
 418 }
 419
 420 BT_EXPORT
 421 const struct bt_stream *bt_trace_borrow_stream_by_id_const(
 422                 const struct bt_trace *trace, uint64_t id)
 423 {
 424         return bt_trace_borrow_stream_by_id((void *) trace, id);
 425 }
 426
 427 BT_EXPORT
 428 enum bt_trace_add_listener_status bt_trace_add_destruction_listener(
 429                 const struct bt_trace *c_trace,
 430                 bt_trace_destruction_listener_func listener,
 431                 void *data, bt_listener_id *listener_id)
 432 {
 433         struct bt_trace *trace = (void *) c_trace;
 434         uint64_t i;
 435         struct bt_trace_destruction_listener_elem new_elem = {
 436                 .func = listener,
 437                 .data = data,
 438         };
 439
 440         BT_ASSERT_PRE_NO_ERROR();
 441         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 442         BT_ASSERT_PRE_LISTENER_FUNC_NON_NULL(listener);
 443
 444         /* Find the next available spot */
 445         for (i = 0; i < trace->destruction_listeners->len; i++) {
 446                 struct bt_trace_destruction_listener_elem elem =
 447                         bt_g_array_index(trace->destruction_listeners,
 448                                 struct bt_trace_destruction_listener_elem, i);
 449
 450                 if (!elem.func) {
 451                         break;
 452                 }
 453         }
 454
 455         if (i == trace->destruction_listeners->len) {
 456                 g_array_append_val(trace->destruction_listeners, new_elem);
 457         } else {
 458                 g_array_insert_val(trace->destruction_listeners, i, new_elem);
 459         }
 460
 461         if (listener_id) {
 462                 *listener_id = i;
 463         }
 464
 465         BT_LIB_LOGD("Added destruction listener: " "%![trace-]+t, "
 466                         "listener-id=%" PRIu64, trace, i);
 467         return BT_FUNC_STATUS_OK;
 468 }
 469
 470 static
 471 bool has_listener_id(const struct bt_trace *trace, uint64_t listener_id)
 472 {
 473         BT_ASSERT(listener_id < trace->destruction_listeners->len);
 474         return (&bt_g_array_index(trace->destruction_listeners,
 475                         struct bt_trace_destruction_listener_elem,
 476                         listener_id))->func;
 477 }
 478
 479 BT_EXPORT
 480 enum bt_trace_remove_listener_status bt_trace_remove_destruction_listener(
 481                 const struct bt_trace *c_trace, bt_listener_id listener_id)
 482 {
 483         struct bt_trace *trace = (void *) c_trace;
 484         struct bt_trace_destruction_listener_elem *elem;
 485
 486         BT_ASSERT_PRE_NO_ERROR();
 487         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 488         BT_ASSERT_PRE("listener-id-exists",
 489                 has_listener_id(trace, listener_id),
 490                 "Trace has no such trace destruction listener ID: "
 491                 "%![trace-]+t, %" PRIu64, trace, listener_id);
 492         elem = &bt_g_array_index(trace->destruction_listeners,
 493                         struct bt_trace_destruction_listener_elem,
 494                         listener_id);
 495         BT_ASSERT(elem->func);
 496
 497         elem->func = NULL;
 498         elem->data = NULL;
 499         BT_LIB_LOGD("Removed \"trace destruction listener: "
 500                 "%![trace-]+t, listener-id=%" PRIu64,
 501                 trace, listener_id);
 502         return BT_FUNC_STATUS_OK;
 503 }
 504
 505 void _bt_trace_freeze(const struct bt_trace *trace)
 506 {
 507         BT_ASSERT(trace);
 508         BT_LIB_LOGD("Freezing trace's class: %!+T", trace->class);
 509         bt_trace_class_freeze(trace->class);
 510         BT_LIB_LOGD("Freezing trace's user attributes: %!+v",
 511                 trace->user_attributes);
 512         bt_value_freeze(trace->user_attributes);
 513         BT_LIB_LOGD("Freezing trace: %!+t", trace);
 514         ((struct bt_trace *) trace)->frozen = true;
 515 }
 516
 517 void bt_trace_add_stream(struct bt_trace *trace, struct bt_stream *stream)
 518 {
 519         guint count = 0;
 520
 521         bt_object_set_parent(&stream->base, &trace->base);
 522         g_ptr_array_add(trace->streams, stream);
 523         bt_trace_freeze(trace);
 524
 525         if (bt_g_hash_table_contains(trace->stream_classes_stream_count,
 526                         stream->class)) {
 527                 count = GPOINTER_TO_UINT(g_hash_table_lookup(
 528                         trace->stream_classes_stream_count, stream->class));
 529         }
 530
 531         g_hash_table_insert(trace->stream_classes_stream_count,
 532                 stream->class, GUINT_TO_POINTER(count + 1));
 533 }
 534
 535 uint64_t bt_trace_get_automatic_stream_id(const struct bt_trace *trace,
 536                 const struct bt_stream_class *stream_class)
 537 {
 538         gpointer orig_key;
 539         gpointer value;
 540         uint64_t id = 0;
 541
 542         BT_ASSERT(stream_class);
 543         BT_ASSERT(trace);
 544         if (g_hash_table_lookup_extended(trace->stream_classes_stream_count,
 545                         stream_class, &orig_key, &value)) {
 546                 id = (uint64_t) GPOINTER_TO_UINT(value);
 547         }
 548
 549         return id;
 550 }
 551
 552 BT_EXPORT
 553 struct bt_trace_class *bt_trace_borrow_class(struct bt_trace *trace)
 554 {
 555         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 556         return trace->class;
 557 }
 558
 559 BT_EXPORT
 560 const struct bt_trace_class *bt_trace_borrow_class_const(
 561                 const struct bt_trace *trace)
 562 {
 563         return bt_trace_borrow_class((void *) trace);
 564 }
 565
 566 BT_EXPORT
 567 const struct bt_value *bt_trace_borrow_user_attributes_const(
 568                 const struct bt_trace *trace)
 569 {
 570         BT_ASSERT_PRE_DEV_TRACE_NON_NULL(trace);
 571         return trace->user_attributes;
 572 }
 573
 574 BT_EXPORT
 575 struct bt_value *bt_trace_borrow_user_attributes(struct bt_trace *trace)
 576 {
 577         return (void *) bt_trace_borrow_user_attributes_const((void *) trace);
 578 }
 579
 580 BT_EXPORT
 581 void bt_trace_set_user_attributes(
 582                 struct bt_trace *trace,
 583                 const struct bt_value *user_attributes)
 584 {
 585         BT_ASSERT_PRE_TRACE_NON_NULL(trace);
 586         BT_ASSERT_PRE_USER_ATTRS_NON_NULL(user_attributes);
 587         BT_ASSERT_PRE_USER_ATTRS_IS_MAP(user_attributes);
 588         BT_ASSERT_PRE_DEV_TRACE_HOT(trace);
 589         bt_object_put_ref_no_null_check(trace->user_attributes);
 590         trace->user_attributes = (void *) user_attributes;
 591         bt_object_get_ref_no_null_check(trace->user_attributes);
 592 }
 593
 594 BT_EXPORT
 595 void bt_trace_get_ref(const struct bt_trace *trace)
 596 {
 597         bt_object_get_ref(trace);
 598 }
 599
 600 BT_EXPORT
 601 void bt_trace_put_ref(const struct bt_trace *trace)
 602 {
 603         bt_object_put_ref(trace);
 604 }