lib: make BT_ASSERT_{PRE,POST}() always on; add BT_ASSERT_{PRE,POST}_DEV()
[babeltrace.git] / src / lib / trace-ir / trace.c
... / ...
CommitLineData
1/*
2 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
3 * Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 */
23
24#define BT_LOG_TAG "LIB/TRACE"
25#include "lib/logging.h"
26
27#include "lib/assert-pre.h"
28#include <babeltrace2/trace-ir/trace.h>
29#include <babeltrace2/trace-ir/trace-const.h>
30#include <babeltrace2/trace-ir/event-class.h>
31#include "ctf-writer/functor.h"
32#include "ctf-writer/clock.h"
33#include "compat/compiler.h"
34#include <babeltrace2/value.h>
35#include <babeltrace2/value-const.h>
36#include "lib/value.h"
37#include <babeltrace2/types.h>
38#include "compat/endian.h"
39#include "common/assert.h"
40#include "compat/glib.h"
41#include <inttypes.h>
42#include <stdint.h>
43#include <string.h>
44#include <stdlib.h>
45
46#include "attributes.h"
47#include "clock-class.h"
48#include "event-class.h"
49#include "event.h"
50#include "field-class.h"
51#include "field-wrapper.h"
52#include "resolve-field-path.h"
53#include "stream-class.h"
54#include "stream.h"
55#include "trace-class.h"
56#include "trace.h"
57#include "utils.h"
58#include "lib/func-status.h"
59
60struct bt_trace_destruction_listener_elem {
61 bt_trace_destruction_listener_func func;
62 void *data;
63};
64
65#define BT_ASSERT_PRE_DEV_TRACE_HOT(_trace) \
66 BT_ASSERT_PRE_DEV_HOT((_trace), "Trace", ": %!+t", (_trace))
67
68static
69void destroy_trace(struct bt_object *obj)
70{
71 struct bt_trace *trace = (void *) obj;
72
73 BT_LIB_LOGD("Destroying trace object: %!+t", trace);
74
75 /*
76 * Call destruction listener functions so that everything else
77 * still exists in the trace.
78 */
79 if (trace->destruction_listeners) {
80 uint64_t i;
81 BT_LIB_LOGD("Calling trace destruction listener(s): %!+t", trace);
82
83 /*
84 * The trace's reference count is 0 if we're here. Increment
85 * it to avoid a double-destroy (possibly infinitely recursive).
86 * This could happen for example if a destruction listener did
87 * bt_object_get_ref() (or anything that causes
88 * bt_object_get_ref() to be called) on the trace (ref.
89 * count goes from 0 to 1), and then bt_object_put_ref(): the
90 * reference count would go from 1 to 0 again and this function
91 * would be called again.
92 */
93 trace->base.ref_count++;
94
95 /* Call all the trace destruction listeners */
96 for (i = 0; i < trace->destruction_listeners->len; i++) {
97 struct bt_trace_destruction_listener_elem elem =
98 g_array_index(trace->destruction_listeners,
99 struct bt_trace_destruction_listener_elem, i);
100
101 if (elem.func) {
102 elem.func(trace, elem.data);
103 }
104
105 /*
106 * The destruction listener should not have kept a
107 * reference to the trace.
108 */
109 BT_ASSERT_PRE(trace->base.ref_count == 1, "Destruction listener kept a reference to the trace being destroyed: %![trace-]+t", trace);
110 }
111 g_array_free(trace->destruction_listeners, TRUE);
112 trace->destruction_listeners = NULL;
113 }
114
115 if (trace->name.str) {
116 g_string_free(trace->name.str, TRUE);
117 trace->name.str = NULL;
118 trace->name.value = NULL;
119 }
120
121 if (trace->environment) {
122 BT_LOGD_STR("Destroying environment attributes.");
123 bt_attributes_destroy(trace->environment);
124 trace->environment = NULL;
125 }
126
127 if (trace->streams) {
128 BT_LOGD_STR("Destroying streams.");
129 g_ptr_array_free(trace->streams, TRUE);
130 trace->streams = NULL;
131 }
132
133 if (trace->stream_classes_stream_count) {
134 g_hash_table_destroy(trace->stream_classes_stream_count);
135 trace->stream_classes_stream_count = NULL;
136 }
137
138 BT_LOGD_STR("Putting trace's class.");
139 bt_object_put_ref(trace->class);
140 trace->class = NULL;
141 g_free(trace);
142}
143
144struct bt_trace *bt_trace_create(struct bt_trace_class *tc)
145{
146 struct bt_trace *trace = NULL;
147
148 BT_LIB_LOGD("Creating trace object: %![tc-]+T", tc);
149 trace = g_new0(struct bt_trace, 1);
150 if (!trace) {
151 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one trace.");
152 goto error;
153 }
154
155 bt_object_init_shared(&trace->base, destroy_trace);
156 trace->streams = g_ptr_array_new_with_free_func(
157 (GDestroyNotify) bt_object_try_spec_release);
158 if (!trace->streams) {
159 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray.");
160 goto error;
161 }
162
163 trace->stream_classes_stream_count = g_hash_table_new(g_direct_hash,
164 g_direct_equal);
165 if (!trace->stream_classes_stream_count) {
166 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GHashTable.");
167 goto error;
168 }
169
170 trace->name.str = g_string_new(NULL);
171 if (!trace->name.str) {
172 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GString.");
173 goto error;
174 }
175
176 trace->environment = bt_attributes_create();
177 if (!trace->environment) {
178 BT_LIB_LOGE_APPEND_CAUSE("Cannot create empty attributes object.");
179 goto error;
180 }
181
182 trace->destruction_listeners = g_array_new(FALSE, TRUE,
183 sizeof(struct bt_trace_destruction_listener_elem));
184 if (!trace->destruction_listeners) {
185 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GArray.");
186 goto error;
187 }
188
189 trace->class = tc;
190 bt_object_get_no_null_check(trace->class);
191 BT_LIB_LOGD("Created trace object: %!+t", trace);
192 goto end;
193
194error:
195 BT_OBJECT_PUT_REF_AND_RESET(trace);
196
197end:
198 return trace;
199}
200
201const char *bt_trace_get_name(const struct bt_trace *trace)
202{
203 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
204 return trace->name.value;
205}
206
207enum bt_trace_set_name_status bt_trace_set_name(struct bt_trace *trace,
208 const char *name)
209{
210 BT_ASSERT_PRE_NON_NULL(trace, "Trace");
211 BT_ASSERT_PRE_NON_NULL(name, "Name");
212 BT_ASSERT_PRE_DEV_TRACE_HOT(trace);
213 g_string_assign(trace->name.str, name);
214 trace->name.value = trace->name.str->str;
215 BT_LIB_LOGD("Set trace's name: %!+t", trace);
216 return BT_FUNC_STATUS_OK;
217}
218
219bt_uuid bt_trace_get_uuid(const struct bt_trace *trace)
220{
221 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
222 return trace->uuid.value;
223}
224
225void bt_trace_set_uuid(struct bt_trace *trace, bt_uuid uuid)
226{
227 BT_ASSERT_PRE_NON_NULL(trace, "Trace");
228 BT_ASSERT_PRE_NON_NULL(uuid, "UUID");
229 BT_ASSERT_PRE_DEV_TRACE_HOT(trace);
230 bt_uuid_copy(trace->uuid.uuid, uuid);
231 trace->uuid.value = trace->uuid.uuid;
232 BT_LIB_LOGD("Set trace's UUID: %!+t", trace);
233}
234
235BT_ASSERT_FUNC
236static
237bool trace_has_environment_entry(const struct bt_trace *trace, const char *name)
238{
239 BT_ASSERT(trace);
240
241 return bt_attributes_borrow_field_value_by_name(
242 trace->environment, name) != NULL;
243}
244
245static
246enum bt_trace_set_environment_entry_status set_environment_entry(
247 struct bt_trace *trace,
248 const char *name, struct bt_value *value)
249{
250 int ret;
251
252 BT_ASSERT(trace);
253 BT_ASSERT(name);
254 BT_ASSERT(value);
255 BT_ASSERT_PRE(!trace->frozen ||
256 !trace_has_environment_entry(trace, name),
257 "Trace is frozen: cannot replace environment entry: "
258 "%![trace-]+t, entry-name=\"%s\"", trace, name);
259 ret = bt_attributes_set_field_value(trace->environment, name,
260 value);
261 if (ret) {
262 ret = BT_FUNC_STATUS_MEMORY_ERROR;
263 BT_LIB_LOGE_APPEND_CAUSE(
264 "Cannot set trace's environment entry: "
265 "%![trace-]+t, entry-name=\"%s\"", trace, name);
266 } else {
267 bt_value_freeze(value);
268 BT_LIB_LOGD("Set trace's environment entry: "
269 "%![trace-]+t, entry-name=\"%s\"", trace, name);
270 }
271
272 return ret;
273}
274
275enum bt_trace_set_environment_entry_status
276bt_trace_set_environment_entry_string(
277 struct bt_trace *trace, const char *name, const char *value)
278{
279 int ret;
280 struct bt_value *value_obj;
281 BT_ASSERT_PRE_NON_NULL(trace, "Trace");
282 BT_ASSERT_PRE_NON_NULL(name, "Name");
283 BT_ASSERT_PRE_NON_NULL(value, "Value");
284 value_obj = bt_value_string_create_init(value);
285 if (!value_obj) {
286 BT_LIB_LOGE_APPEND_CAUSE(
287 "Cannot create a string value object.");
288 ret = -1;
289 goto end;
290 }
291
292 /* set_environment_entry() logs errors */
293 ret = set_environment_entry(trace, name, value_obj);
294
295end:
296 bt_object_put_ref(value_obj);
297 return ret;
298}
299
300enum bt_trace_set_environment_entry_status
301bt_trace_set_environment_entry_integer(
302 struct bt_trace *trace, const char *name, int64_t value)
303{
304 int ret;
305 struct bt_value *value_obj;
306 BT_ASSERT_PRE_NON_NULL(trace, "Trace");
307 BT_ASSERT_PRE_NON_NULL(name, "Name");
308 value_obj = bt_value_signed_integer_create_init(value);
309 if (!value_obj) {
310 BT_LIB_LOGE_APPEND_CAUSE(
311 "Cannot create an integer value object.");
312 ret = BT_FUNC_STATUS_MEMORY_ERROR;
313 goto end;
314 }
315
316 /* set_environment_entry() logs errors */
317 ret = set_environment_entry(trace, name, value_obj);
318
319end:
320 bt_object_put_ref(value_obj);
321 return ret;
322}
323
324uint64_t bt_trace_get_environment_entry_count(const struct bt_trace *trace)
325{
326 int64_t ret;
327
328 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
329 ret = bt_attributes_get_count(trace->environment);
330 BT_ASSERT(ret >= 0);
331 return (uint64_t) ret;
332}
333
334void bt_trace_borrow_environment_entry_by_index_const(
335 const struct bt_trace *trace, uint64_t index,
336 const char **name, const struct bt_value **value)
337{
338 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
339 BT_ASSERT_PRE_DEV_NON_NULL(name, "Name");
340 BT_ASSERT_PRE_DEV_NON_NULL(value, "Value");
341 BT_ASSERT_PRE_DEV_VALID_INDEX(index,
342 bt_attributes_get_count(trace->environment));
343 *value = bt_attributes_borrow_field_value(trace->environment, index);
344 BT_ASSERT(*value);
345 *name = bt_attributes_get_field_name(trace->environment, index);
346 BT_ASSERT(*name);
347}
348
349const struct bt_value *bt_trace_borrow_environment_entry_value_by_name_const(
350 const struct bt_trace *trace, const char *name)
351{
352 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
353 BT_ASSERT_PRE_DEV_NON_NULL(name, "Name");
354 return bt_attributes_borrow_field_value_by_name(trace->environment,
355 name);
356}
357
358uint64_t bt_trace_get_stream_count(const struct bt_trace *trace)
359{
360 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
361 return (uint64_t) trace->streams->len;
362}
363
364struct bt_stream *bt_trace_borrow_stream_by_index(
365 struct bt_trace *trace, uint64_t index)
366{
367 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
368 BT_ASSERT_PRE_DEV_VALID_INDEX(index, trace->streams->len);
369 return g_ptr_array_index(trace->streams, index);
370}
371
372const struct bt_stream *bt_trace_borrow_stream_by_index_const(
373 const struct bt_trace *trace, uint64_t index)
374{
375 return bt_trace_borrow_stream_by_index((void *) trace, index);
376}
377
378struct bt_stream *bt_trace_borrow_stream_by_id(struct bt_trace *trace,
379 uint64_t id)
380{
381 struct bt_stream *stream = NULL;
382 uint64_t i;
383
384 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
385
386 for (i = 0; i < trace->streams->len; i++) {
387 struct bt_stream *stream_candidate =
388 g_ptr_array_index(trace->streams, i);
389
390 if (stream_candidate->id == id) {
391 stream = stream_candidate;
392 goto end;
393 }
394 }
395
396end:
397 return stream;
398}
399
400const struct bt_stream *bt_trace_borrow_stream_by_id_const(
401 const struct bt_trace *trace, uint64_t id)
402{
403 return bt_trace_borrow_stream_by_id((void *) trace, id);
404}
405
406enum bt_trace_add_listener_status bt_trace_add_destruction_listener(
407 const struct bt_trace *c_trace,
408 bt_trace_destruction_listener_func listener,
409 void *data, uint64_t *listener_id)
410{
411 struct bt_trace *trace = (void *) c_trace;
412 uint64_t i;
413 struct bt_trace_destruction_listener_elem new_elem = {
414 .func = listener,
415 .data = data,
416 };
417
418 BT_ASSERT_PRE_NON_NULL(trace, "Trace");
419 BT_ASSERT_PRE_NON_NULL(listener, "Listener");
420
421 /* Find the next available spot */
422 for (i = 0; i < trace->destruction_listeners->len; i++) {
423 struct bt_trace_destruction_listener_elem elem =
424 g_array_index(trace->destruction_listeners,
425 struct bt_trace_destruction_listener_elem, i);
426
427 if (!elem.func) {
428 break;
429 }
430 }
431
432 if (i == trace->destruction_listeners->len) {
433 g_array_append_val(trace->destruction_listeners, new_elem);
434 } else {
435 g_array_insert_val(trace->destruction_listeners, i, new_elem);
436 }
437
438 if (listener_id) {
439 *listener_id = i;
440 }
441
442 BT_LIB_LOGD("Added destruction listener: " "%![trace-]+t, "
443 "listener-id=%" PRIu64, trace, i);
444 return BT_FUNC_STATUS_OK;
445}
446
447BT_ASSERT_PRE_FUNC
448static
449bool has_listener_id(const struct bt_trace *trace, uint64_t listener_id)
450{
451 BT_ASSERT(listener_id < trace->destruction_listeners->len);
452 return (&g_array_index(trace->destruction_listeners,
453 struct bt_trace_destruction_listener_elem,
454 listener_id))->func != NULL;
455}
456
457enum bt_trace_remove_listener_status bt_trace_remove_destruction_listener(
458 const struct bt_trace *c_trace, uint64_t listener_id)
459{
460 struct bt_trace *trace = (void *) c_trace;
461 struct bt_trace_destruction_listener_elem *elem;
462
463 BT_ASSERT_PRE_NON_NULL(trace, "Trace");
464 BT_ASSERT_PRE(has_listener_id(trace, listener_id),
465 "Trace has no such trace destruction listener ID: "
466 "%![trace-]+t, %" PRIu64, trace, listener_id);
467 elem = &g_array_index(trace->destruction_listeners,
468 struct bt_trace_destruction_listener_elem,
469 listener_id);
470 BT_ASSERT(elem->func);
471
472 elem->func = NULL;
473 elem->data = NULL;
474 BT_LIB_LOGD("Removed \"trace destruction listener: "
475 "%![trace-]+t, listener-id=%" PRIu64,
476 trace, listener_id);
477 return BT_FUNC_STATUS_OK;
478}
479
480BT_HIDDEN
481void _bt_trace_freeze(const struct bt_trace *trace)
482{
483 BT_ASSERT(trace);
484 BT_LIB_LOGD("Freezing trace's class: %!+T", trace->class);
485 bt_trace_class_freeze(trace->class);
486 BT_LIB_LOGD("Freezing trace: %!+t", trace);
487 ((struct bt_trace *) trace)->frozen = true;
488}
489
490BT_HIDDEN
491void bt_trace_add_stream(struct bt_trace *trace, struct bt_stream *stream)
492{
493 guint count = 0;
494
495 bt_object_set_parent(&stream->base, &trace->base);
496 g_ptr_array_add(trace->streams, stream);
497 bt_trace_freeze(trace);
498
499 if (bt_g_hash_table_contains(trace->stream_classes_stream_count,
500 stream->class)) {
501 count = GPOINTER_TO_UINT(g_hash_table_lookup(
502 trace->stream_classes_stream_count, stream->class));
503 }
504
505 g_hash_table_insert(trace->stream_classes_stream_count,
506 stream->class, GUINT_TO_POINTER(count + 1));
507}
508
509BT_HIDDEN
510uint64_t bt_trace_get_automatic_stream_id(const struct bt_trace *trace,
511 const struct bt_stream_class *stream_class)
512{
513 gpointer orig_key;
514 gpointer value;
515 uint64_t id = 0;
516
517 BT_ASSERT(stream_class);
518 BT_ASSERT(trace);
519 if (g_hash_table_lookup_extended(trace->stream_classes_stream_count,
520 stream_class, &orig_key, &value)) {
521 id = (uint64_t) GPOINTER_TO_UINT(value);
522 }
523
524 return id;
525}
526
527struct bt_trace_class *bt_trace_borrow_class(struct bt_trace *trace)
528{
529 BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
530 return trace->class;
531}
532
533const struct bt_trace_class *bt_trace_borrow_class_const(
534 const struct bt_trace *trace)
535{
536 return bt_trace_borrow_class((void *) trace);
537}
538
539void bt_trace_get_ref(const struct bt_trace *trace)
540{
541 bt_object_get_ref(trace);
542}
543
544void bt_trace_put_ref(const struct bt_trace *trace)
545{
546 bt_object_put_ref(trace);
547}
This page took 0.024585 seconds and 4 git commands to generate.