Fix: fix some warnings shown with -Wextra on gcc 9.1.0
[babeltrace.git] / src / ctf-writer / event.c
CommitLineData
3dca2276
PP
1/*
2 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 * Copyright 2017-2018 Philippe Proulx <pproulx@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
350ad6c1 24#define BT_LOG_TAG "CTF-WRITER/EVENT"
67d2ce02 25#include "logging.h"
3dca2276 26
578e048b
MJ
27#include <inttypes.h>
28
217cf9d3
PP
29#include <babeltrace2-ctf-writer/event.h>
30#include <babeltrace2-ctf-writer/fields.h>
31#include <babeltrace2-ctf-writer/field-types.h>
32#include <babeltrace2-ctf-writer/object.h>
33#include <babeltrace2-ctf-writer/stream-class.h>
34#include <babeltrace2-ctf-writer/trace.h>
35#include <babeltrace2-ctf-writer/utils.h>
578e048b
MJ
36
37#include "common/assert.h"
38#include "compat/compiler.h"
39
40#include "assert-pre.h"
41#include "attributes.h"
42#include "clock-class.h"
43#include "clock.h"
44#include "event-class.h"
45#include "event.h"
46#include "fields.h"
47#include "field-types.h"
48#include "stream-class.h"
49#include "stream.h"
50#include "trace.h"
51#include "validation.h"
3dca2276
PP
52
53static
16ca5ff0
PP
54int bt_ctf_event_common_validate_types_for_create(
55 struct bt_ctf_event_class_common *event_class,
56 struct bt_ctf_validation_output *validation_output,
57 bt_ctf_validation_flag_copy_field_type_func copy_field_type_func)
58{
59 int ret;
60 enum bt_ctf_validation_flag validation_flags =
61 BT_CTF_VALIDATION_FLAG_STREAM |
62 BT_CTF_VALIDATION_FLAG_EVENT;
63 struct bt_ctf_trace_common *trace = NULL;
64 struct bt_ctf_stream_class_common *stream_class = NULL;
65 struct bt_ctf_field_type_common *packet_header_type = NULL;
66 struct bt_ctf_field_type_common *packet_context_type = NULL;
67 struct bt_ctf_field_type_common *event_header_type = NULL;
68 struct bt_ctf_field_type_common *stream_event_ctx_type = NULL;
69 struct bt_ctf_field_type_common *event_context_type = NULL;
70 struct bt_ctf_field_type_common *event_payload_type = NULL;
71 int trace_valid = 0;
e1e02a22 72 struct bt_ctf_private_value *environment = NULL;
16ca5ff0
PP
73
74 stream_class = bt_ctf_event_class_common_borrow_stream_class(event_class);
75 BT_ASSERT(stream_class);
76 trace = bt_ctf_stream_class_common_borrow_trace(stream_class);
77 if (trace) {
78 BT_LOGD_STR("Event class is part of a trace.");
79 packet_header_type =
80 bt_ctf_trace_common_borrow_packet_header_field_type(trace);
81 trace_valid = trace->valid;
82 BT_ASSERT(trace_valid);
83 environment = trace->environment;
84 }
85
86 packet_context_type =
87 bt_ctf_stream_class_common_borrow_packet_context_field_type(
88 stream_class);
89 event_header_type =
90 bt_ctf_stream_class_common_borrow_event_header_field_type(
91 stream_class);
92 stream_event_ctx_type =
93 bt_ctf_stream_class_common_borrow_event_context_field_type(
94 stream_class);
95 event_context_type =
96 bt_ctf_event_class_common_borrow_context_field_type(event_class);
97 event_payload_type =
98 bt_ctf_event_class_common_borrow_payload_field_type(event_class);
99 ret = bt_ctf_validate_class_types(environment, packet_header_type,
100 packet_context_type, event_header_type, stream_event_ctx_type,
101 event_context_type, event_payload_type, trace_valid,
102 stream_class->valid, event_class->valid,
103 validation_output, validation_flags, copy_field_type_func);
104 if (ret) {
105 /*
106 * This means something went wrong during the validation
107 * process, not that the objects are invalid.
108 */
109 BT_LOGE("Failed to validate event and parents: ret=%d", ret);
110 goto error;
111 }
112
113 if ((validation_output->valid_flags & validation_flags) !=
114 validation_flags) {
115 /* Invalid trace/stream class/event class */
116 BT_LOGW("Invalid trace, stream class, or event class: "
117 "valid-flags=0x%x", validation_output->valid_flags);
118 goto error;
119 }
120
121 goto end;
122
123error:
124 bt_ctf_validation_output_put_types(validation_output);
125 ret = -1;
126
127end:
128 return ret;
129}
3dca2276
PP
130
131static
16ca5ff0
PP
132int bt_ctf_event_common_create_fields(
133 struct bt_ctf_stream_class_common *stream_class,
134 struct bt_ctf_validation_output *validation_output,
135 create_field_func create_field_func,
136 release_field_func release_field_func,
137 create_header_field_func create_header_field_func,
138 release_header_field_func release_header_field_func,
139 struct bt_ctf_field_wrapper **header_field,
140 struct bt_ctf_field_common **stream_event_context_field,
141 struct bt_ctf_field_common **context_field,
142 struct bt_ctf_field_common **payload_field)
143{
144 int ret = 0;
145
146 if (validation_output->event_header_type) {
147 BT_LOGD("Creating initial event header field: ft-addr=%p",
148 validation_output->event_header_type);
149 *header_field =
150 create_header_field_func(stream_class,
151 validation_output->event_header_type);
152 if (!*header_field) {
153 BT_LOGE_STR("Cannot create initial event header field object.");
154 goto error;
155 }
156 }
157
158 if (validation_output->stream_event_ctx_type) {
159 BT_LOGD("Creating initial stream event context field: ft-addr=%p",
160 validation_output->stream_event_ctx_type);
161 *stream_event_context_field = create_field_func(
162 validation_output->stream_event_ctx_type);
163 if (!*stream_event_context_field) {
164 BT_LOGE_STR("Cannot create initial stream event context field object.");
165 goto error;
166 }
167 }
168
169 if (validation_output->event_context_type) {
170 BT_LOGD("Creating initial event context field: ft-addr=%p",
171 validation_output->event_context_type);
172 *context_field = create_field_func(
173 validation_output->event_context_type);
174 if (!*context_field) {
175 BT_LOGE_STR("Cannot create initial event context field object.");
176 goto error;
177 }
178 }
179
180 if (validation_output->event_payload_type) {
181 BT_LOGD("Creating initial event payload field: ft-addr=%p",
182 validation_output->event_payload_type);
183 *payload_field = create_field_func(
184 validation_output->event_payload_type);
185 if (!*payload_field) {
186 BT_LOGE_STR("Cannot create initial event payload field object.");
187 goto error;
188 }
189 }
190
191 goto end;
192
193error:
194 if (*header_field) {
195 release_header_field_func(*header_field, stream_class);
196 }
197
198 if (*stream_event_context_field) {
199 release_field_func(*stream_event_context_field);
200 }
201
202 if (*context_field) {
203 release_field_func(*context_field);
204 }
205
206 if (*payload_field) {
207 release_field_func(*payload_field);
208 }
209
210 ret = -1;
211
212end:
213 return ret;
214}
215
216BT_HIDDEN
217int _bt_ctf_event_common_validate(struct bt_ctf_event_common *event)
218{
219 int ret = 0;
220 struct bt_ctf_stream_class_common *stream_class;
221
222 BT_ASSERT(event);
223 if (event->header_field) {
224 ret = bt_ctf_field_common_validate_recursive(
225 event->header_field->field);
226 if (ret) {
67d2ce02 227 BT_CTF_ASSERT_PRE_MSG("Invalid event's header field: "
16ca5ff0
PP
228 "event-addr=%p, field-addr=%p",
229 event, event->header_field->field);
230 goto end;
231 }
232 }
233
234 stream_class = bt_ctf_event_class_common_borrow_stream_class(event->class);
235
236 /*
237 * We should not have been able to create the event without associating
238 * the event class to a stream class.
239 */
240 BT_ASSERT(stream_class);
241
242 if (stream_class->event_context_field_type) {
243 ret = bt_ctf_field_common_validate_recursive(
244 event->stream_event_context_field);
245 if (ret) {
67d2ce02 246 BT_CTF_ASSERT_PRE_MSG("Invalid event's stream event context field: "
16ca5ff0
PP
247 "event-addr=%p, field-addr=%p",
248 event, event->stream_event_context_field);
249 goto end;
250 }
251 }
252
253 if (event->class->context_field_type) {
254 ret = bt_ctf_field_common_validate_recursive(event->context_field);
255 if (ret) {
67d2ce02 256 BT_CTF_ASSERT_PRE_MSG("Invalid event's payload field: "
16ca5ff0
PP
257 "event-addr=%p, field-addr=%p",
258 event, event->context_field);
259 goto end;
260 }
261 }
262
263 ret = bt_ctf_field_common_validate_recursive(event->payload_field);
264 if (ret) {
67d2ce02 265 BT_CTF_ASSERT_PRE_MSG("Invalid event's payload field: "
16ca5ff0
PP
266 "event-addr=%p, field-addr=%p",
267 event, event->payload_field);
268 goto end;
269 }
270
271end:
272 return ret;
273}
274
275BT_HIDDEN
276void _bt_ctf_event_common_set_is_frozen(struct bt_ctf_event_common *event,
277 bool is_frozen)
278{
279 BT_ASSERT(event);
280 BT_LOGD("Freezing event: addr=%p, "
281 "event-class-name=\"%s\", event-class-id=%" PRId64,
282 event, bt_ctf_event_class_common_get_name(event->class),
283 bt_ctf_event_class_common_get_id(event->class));
284
285 if (event->header_field) {
286 BT_LOGD_STR("Freezing event's header field.");
287 bt_ctf_field_common_set_is_frozen_recursive(
288 event->header_field->field, is_frozen);
289 }
290
291 if (event->stream_event_context_field) {
292 BT_LOGD_STR("Freezing event's stream event context field.");
293 bt_ctf_field_common_set_is_frozen_recursive(
294 event->stream_event_context_field, is_frozen);
295 }
296
297 if (event->context_field) {
298 BT_LOGD_STR("Freezing event's context field.");
299 bt_ctf_field_common_set_is_frozen_recursive(event->context_field,
300 is_frozen);
301 }
302
303 if (event->payload_field) {
304 BT_LOGD_STR("Freezing event's payload field.");
305 bt_ctf_field_common_set_is_frozen_recursive(event->payload_field,
306 is_frozen);
307 }
308
309 event->frozen = is_frozen;
310}
311
312BT_HIDDEN
313int bt_ctf_event_common_initialize(struct bt_ctf_event_common *event,
314 struct bt_ctf_event_class_common *event_class,
315 struct bt_ctf_clock_class *init_expected_clock_class,
e1e02a22 316 bool is_shared_with_parent, bt_ctf_object_release_func release_func,
16ca5ff0
PP
317 bt_ctf_validation_flag_copy_field_type_func field_type_copy_func,
318 bool must_be_in_trace,
319 int (*map_clock_classes_func)(struct bt_ctf_stream_class_common *stream_class,
320 struct bt_ctf_field_type_common *packet_context_field_type,
321 struct bt_ctf_field_type_common *event_header_field_type),
322 create_field_func create_field_func,
323 release_field_func release_field_func,
324 create_header_field_func create_header_field_func,
325 release_header_field_func release_header_field_func)
326{
327 int ret;
328 struct bt_ctf_trace_common *trace = NULL;
329 struct bt_ctf_stream_class_common *stream_class = NULL;
330 struct bt_ctf_field_wrapper *event_header = NULL;
331 struct bt_ctf_field_common *stream_event_context = NULL;
332 struct bt_ctf_field_common *event_context = NULL;
333 struct bt_ctf_field_common *event_payload = NULL;
334 struct bt_ctf_validation_output validation_output = { 0 };
335 struct bt_ctf_clock_class *expected_clock_class =
e1e02a22 336 init_expected_clock_class ? bt_ctf_object_get_ref(init_expected_clock_class) :
16ca5ff0
PP
337 NULL;
338
67d2ce02 339 BT_CTF_ASSERT_PRE_NON_NULL(event_class, "Event class");
16ca5ff0
PP
340 BT_LOGD("Initializing common event object: event-class-addr=%p, "
341 "event-class-name=\"%s\", event-class-id=%" PRId64,
342 event_class, bt_ctf_event_class_common_get_name(event_class),
343 bt_ctf_event_class_common_get_id(event_class));
344
345 stream_class = bt_ctf_event_class_common_borrow_stream_class(event_class);
67d2ce02 346 BT_CTF_ASSERT_PRE(stream_class,
16ca5ff0
PP
347 "Event class is not part of a stream class: event-class-addr=%p",
348 event_class);
349
350 /* The event class was frozen when added to its stream class */
351 BT_ASSERT(event_class->frozen);
352 trace = bt_ctf_stream_class_common_borrow_trace(stream_class);
353
354 if (must_be_in_trace) {
67d2ce02 355 BT_CTF_ASSERT_PRE(trace,
16ca5ff0
PP
356 "Event class's stream class is not part of a trace: "
357 "ec-addr=%p, sc-addr=%p", event_class, stream_class);
358 }
359
360 /*
361 * This must be called before anything that can fail because on
362 * failure, the caller releases the reference to `event` to
363 * destroy it.
364 */
365 if (is_shared_with_parent) {
e1e02a22 366 bt_ctf_object_init_shared_with_parent(&event->base, release_func);
16ca5ff0 367 } else {
e1e02a22 368 bt_ctf_object_init_unique(&event->base);
16ca5ff0
PP
369 }
370
371 if (!stream_class->frozen) {
372 /*
373 * Because this function freezes the stream class,
374 * validate that this stream class contains at most a
375 * single clock class so that we set its expected clock
376 * class for future checks.
377 */
378 ret = bt_ctf_stream_class_common_validate_single_clock_class(
379 stream_class, &expected_clock_class);
380 if (ret) {
381 BT_LOGW("Event class's stream class or one of its event "
382 "classes contains a field type which is not "
383 "recursively mapped to the expected "
384 "clock class: "
385 "stream-class-addr=%p, "
386 "stream-class-id=%" PRId64 ", "
387 "stream-class-name=\"%s\", "
388 "expected-clock-class-addr=%p, "
389 "expected-clock-class-name=\"%s\"",
390 stream_class,
391 bt_ctf_stream_class_common_get_id(stream_class),
392 bt_ctf_stream_class_common_get_name(stream_class),
393 expected_clock_class,
394 expected_clock_class ?
395 bt_ctf_clock_class_get_name(expected_clock_class) :
396 NULL);
397 goto error;
398 }
399 }
400
401 /* Validate the trace, the stream class, and the event class */
402 ret = bt_ctf_event_common_validate_types_for_create(
403 event_class, &validation_output, field_type_copy_func);
404 if (ret) {
405 /* bt_ctf_event_common_validate_types_for_create() logs errors */
406 goto error;
407 }
408
409 if (map_clock_classes_func) {
410 /*
411 * Safe to automatically map selected fields to the
412 * stream's clock's class here because the stream class
413 * is about to be frozen.
414 */
415 if (map_clock_classes_func(stream_class,
416 validation_output.packet_context_type,
417 validation_output.event_header_type)) {
418 BT_LOGW_STR("Cannot automatically map selected stream class's "
419 "field types to stream class's clock's class.");
420 goto error;
421 }
422 }
423
424 /*
425 * event does not share a common ancestor with the event class; it has
426 * to guarantee its existence by holding a reference. This reference
427 * shall be released once the event is associated to a stream since,
428 * from that point, the event and its class will share the same
429 * lifetime.
430 */
e1e02a22 431 event->class = bt_ctf_object_get_ref(event_class);
16ca5ff0
PP
432
433 ret = bt_ctf_event_common_create_fields(stream_class,
434 &validation_output,
435 create_field_func, release_field_func,
436 create_header_field_func, release_header_field_func,
437 &event_header, &stream_event_context, &event_context,
438 &event_payload);
439 if (ret) {
440 /* bt_ctf_event_common_create_fields() logs errors */
441 goto error;
442 }
443
444 /*
445 * At this point all the fields are created, potentially from
446 * validated copies of field types, so that the field types and
447 * fields can be replaced in the trace, stream class,
448 * event class, and created event.
449 */
450 bt_ctf_validation_replace_types(trace, stream_class, event_class,
451 &validation_output,
452 BT_CTF_VALIDATION_FLAG_STREAM | BT_CTF_VALIDATION_FLAG_EVENT);
453 event->header_field = event_header;
454 event_header = NULL;
455 event->stream_event_context_field = stream_event_context;
456 stream_event_context = NULL;
457 event->context_field = event_context;
458 event_context = NULL;
459 event->payload_field = event_payload;
460 event_payload = NULL;
461
462 /*
463 * Put what was not moved in bt_ctf_validation_replace_types().
464 */
465 bt_ctf_validation_output_put_types(&validation_output);
466
467 /*
468 * Freeze the stream class since the event header must not be changed
469 * anymore.
470 */
471 bt_ctf_stream_class_common_freeze(stream_class);
472
473 /*
474 * It is safe to set the stream class's unique clock class
475 * now because the stream class is frozen.
476 */
477 if (expected_clock_class) {
e1e02a22 478 BT_CTF_OBJECT_MOVE_REF(stream_class->clock_class, expected_clock_class);
16ca5ff0
PP
479 }
480
481 /*
482 * Mark stream class, and event class as valid since
483 * they're all frozen now.
484 */
485 stream_class->valid = 1;
486 event_class->valid = 1;
487
488 /* Put stuff we borrowed from the event class */
489 BT_LOGD("Initialized event object: addr=%p, event-class-name=\"%s\", "
490 "event-class-id=%" PRId64,
491 event, bt_ctf_event_class_common_get_name(event->class),
492 bt_ctf_event_class_common_get_id(event->class));
493 goto end;
494
495error:
496 bt_ctf_validation_output_put_types(&validation_output);
e1e02a22 497 bt_ctf_object_put_ref(expected_clock_class);
16ca5ff0
PP
498
499 if (event_header) {
500 release_header_field_func(event_header, stream_class);
501 }
502
503 if (stream_event_context) {
504 release_field_func(stream_event_context);
505 }
506
507 if (event_context) {
508 release_field_func(event_context);
509 }
510
511 if (event_payload) {
512 release_field_func(event_payload);
513 }
514
515 ret = -1;
516
517end:
518 return ret;
519}
520
521int map_clock_classes_func(struct bt_ctf_stream_class_common *stream_class,
522 struct bt_ctf_field_type_common *packet_context_type,
523 struct bt_ctf_field_type_common *event_header_type)
3dca2276
PP
524{
525 int ret = bt_ctf_stream_class_map_clock_class(
16ca5ff0
PP
526 BT_CTF_FROM_COMMON(stream_class),
527 BT_CTF_FROM_COMMON(packet_context_type),
528 BT_CTF_FROM_COMMON(event_header_type));
3dca2276
PP
529
530 if (ret) {
531 BT_LOGW_STR("Cannot automatically map selected stream class's field types to stream class's clock's class.");
532 }
533
534 return ret;
535}
536
312c056a 537static
9c7f2f85
SM
538void destroy_event_header_field(struct bt_ctf_field_wrapper *field_wrapper,
539 struct bt_ctf_stream_class *stream_class)
312c056a
PP
540{
541 BT_ASSERT(field_wrapper);
e1e02a22 542 bt_ctf_object_put_ref(field_wrapper->field);
16ca5ff0 543 bt_ctf_field_wrapper_destroy(field_wrapper);
312c056a
PP
544}
545
546static
16ca5ff0
PP
547struct bt_ctf_field_wrapper *create_event_header_field(
548 struct bt_ctf_stream_class *stream_class,
549 struct bt_ctf_field_type_common *ft)
312c056a 550{
16ca5ff0 551 struct bt_ctf_field_wrapper *field_wrapper = NULL;
312c056a
PP
552 struct bt_ctf_field *field = bt_ctf_field_create((void *) ft);
553
554 if (!field) {
555 goto error;
556 }
557
16ca5ff0 558 field_wrapper = bt_ctf_field_wrapper_new(NULL);
312c056a
PP
559 if (!field_wrapper) {
560 goto error;
561 }
562
563 field_wrapper->field = (void *) field;
564 field = NULL;
565 goto end;
566
567error:
e1e02a22 568 bt_ctf_object_put_ref(field);
312c056a
PP
569
570 if (field_wrapper) {
9c7f2f85 571 destroy_event_header_field(field_wrapper, stream_class);
312c056a
PP
572 field_wrapper = NULL;
573 }
574
575end:
576 return field_wrapper;
577}
578
16ca5ff0
PP
579static
580void release_event_header_field(struct bt_ctf_field_wrapper *field_wrapper,
581 struct bt_ctf_event_common *event_common)
582{
583 BT_ASSERT(field_wrapper);
e1e02a22 584 BT_CTF_OBJECT_PUT_REF_AND_RESET(field_wrapper->field);
16ca5ff0
PP
585 bt_ctf_field_wrapper_destroy(field_wrapper);
586}
587
588static
e1e02a22 589void bt_ctf_event_destroy(struct bt_ctf_object *obj)
16ca5ff0 590{
e1e02a22 591 bt_ctf_event_common_finalize(obj, (void *) bt_ctf_object_put_ref,
16ca5ff0
PP
592 (void *) release_event_header_field);
593 g_free(obj);
594}
595
3dca2276
PP
596struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
597{
598 int ret;
599 struct bt_ctf_event *event = NULL;
16ca5ff0 600 struct bt_ctf_clock_class *expected_clock_class = NULL;
3dca2276
PP
601
602 event = g_new0(struct bt_ctf_event, 1);
603 if (!event) {
604 BT_LOGE_STR("Failed to allocate one CTF writer event.");
605 goto error;
606 }
607
608 if (event_class) {
609 struct bt_ctf_stream_class *stream_class =
16ca5ff0
PP
610 BT_CTF_FROM_COMMON(bt_ctf_event_class_common_borrow_stream_class(
611 BT_CTF_TO_COMMON(event_class)));
3dca2276
PP
612
613 if (stream_class && stream_class->clock) {
16ca5ff0 614 expected_clock_class = stream_class->clock->clock_class;
3dca2276
PP
615 }
616 }
617
16ca5ff0
PP
618 ret = bt_ctf_event_common_initialize(BT_CTF_TO_COMMON(event),
619 BT_CTF_TO_COMMON(event_class), expected_clock_class,
3fea54f6 620 true, bt_ctf_event_destroy,
16ca5ff0 621 (bt_ctf_validation_flag_copy_field_type_func)
3dca2276
PP
622 bt_ctf_field_type_copy,
623 false, map_clock_classes_func,
2dd764c1 624 (create_field_func) bt_ctf_field_create,
e1e02a22 625 (release_field_func) bt_ctf_object_put_ref,
2dd764c1
PP
626 (create_header_field_func) create_event_header_field,
627 (release_header_field_func) destroy_event_header_field);
3dca2276 628 if (ret) {
16ca5ff0 629 /* bt_ctf_event_common_initialize() logs errors */
3dca2276
PP
630 goto error;
631 }
632
633 goto end;
634
635error:
e1e02a22 636 BT_CTF_OBJECT_PUT_REF_AND_RESET(event);
3dca2276
PP
637
638end:
639 return event;
640}
641
642struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event)
643{
67d2ce02 644 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
e1e02a22 645 return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_class(BT_CTF_TO_COMMON(event)));
3dca2276
PP
646}
647
648BT_HIDDEN
649struct bt_ctf_stream *bt_ctf_event_borrow_stream(struct bt_ctf_event *event)
650{
651 BT_ASSERT(event);
652 return (struct bt_ctf_stream *)
e1e02a22 653 bt_ctf_object_borrow_parent(&BT_CTF_TO_COMMON(event)->base);
3dca2276
PP
654}
655
656struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
657{
67d2ce02 658 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
e1e02a22 659 return bt_ctf_object_get_ref(bt_ctf_event_borrow_stream(event));
3dca2276
PP
660}
661
662int bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name,
663 struct bt_ctf_field *field)
664{
67d2ce02
MJ
665 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
666 BT_CTF_ASSERT_PRE_NON_NULL(field, "Payload field");
667 BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
3dca2276 668 return bt_ctf_field_structure_set_field_by_name(
312c056a 669 (void *) event->common.payload_field, name, field);
3dca2276
PP
670}
671
672struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
673 const char *name)
674{
675 struct bt_ctf_field *field = NULL;
676
67d2ce02 677 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
3dca2276
PP
678
679 if (name) {
680 field = bt_ctf_field_structure_get_field_by_name(
16ca5ff0 681 BT_CTF_FROM_COMMON(event->common.payload_field), name);
3dca2276 682 } else {
16ca5ff0 683 field = BT_CTF_FROM_COMMON(event->common.payload_field);
e1e02a22 684 bt_ctf_object_get_ref(field);
3dca2276
PP
685 }
686
687 return field;
688}
689
690struct bt_ctf_field *bt_ctf_event_get_payload_field(
691 struct bt_ctf_event *event)
692{
e1e02a22 693 return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_payload(BT_CTF_TO_COMMON(event)));
3dca2276
PP
694}
695
3dca2276
PP
696struct bt_ctf_field *bt_ctf_event_get_header(struct bt_ctf_event *event)
697{
e1e02a22 698 return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_header(BT_CTF_TO_COMMON(event)));
3dca2276
PP
699}
700
3dca2276
PP
701struct bt_ctf_field *bt_ctf_event_get_context(struct bt_ctf_event *event)
702{
e1e02a22 703 return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_context(BT_CTF_TO_COMMON(event)));
3dca2276
PP
704}
705
3dca2276
PP
706struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
707 struct bt_ctf_event *event)
708{
e1e02a22 709 return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_stream_event_context(
16ca5ff0 710 BT_CTF_TO_COMMON(event)));
3dca2276
PP
711}
712
713BT_HIDDEN
714int bt_ctf_event_serialize(struct bt_ctf_event *event,
013f35c6 715 struct bt_ctfser *ctfser,
3dca2276
PP
716 enum bt_ctf_byte_order native_byte_order)
717{
718 int ret = 0;
719
720 BT_ASSERT(event);
013f35c6 721 BT_ASSERT(ctfser);
3dca2276 722
ef267d12 723 BT_LOGT_STR("Serializing event's context field.");
3dca2276
PP
724 if (event->common.context_field) {
725 ret = bt_ctf_field_serialize_recursive(
013f35c6 726 (void *) event->common.context_field, ctfser,
3dca2276
PP
727 native_byte_order);
728 if (ret) {
729 BT_LOGW("Cannot serialize event's context field: "
730 "event-addr=%p, event-class-name=\"%s\", "
731 "event-class-id=%" PRId64,
732 event,
16ca5ff0
PP
733 bt_ctf_event_class_common_get_name(event->common.class),
734 bt_ctf_event_class_common_get_id(event->common.class));
3dca2276
PP
735 goto end;
736 }
737 }
738
ef267d12 739 BT_LOGT_STR("Serializing event's payload field.");
3dca2276
PP
740 if (event->common.payload_field) {
741 ret = bt_ctf_field_serialize_recursive(
013f35c6 742 (void *) event->common.payload_field, ctfser,
3dca2276
PP
743 native_byte_order);
744 if (ret) {
745 BT_LOGW("Cannot serialize event's payload field: "
746 "event-addr=%p, event-class-name=\"%s\", "
747 "event-class-id=%" PRId64,
748 event,
16ca5ff0
PP
749 bt_ctf_event_class_common_get_name(event->common.class),
750 bt_ctf_event_class_common_get_id(event->common.class));
3dca2276
PP
751 goto end;
752 }
753 }
754
755end:
756 return ret;
757}
758
759BT_HIDDEN
760void _bt_ctf_event_freeze(struct bt_ctf_event *event)
761{
16ca5ff0 762 _bt_ctf_event_common_set_is_frozen(BT_CTF_TO_COMMON(event), true);
3dca2276 763}
312c056a
PP
764
765int bt_ctf_event_set_header(struct bt_ctf_event *event,
766 struct bt_ctf_field *header)
767{
67d2ce02
MJ
768 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
769 BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
312c056a
PP
770
771 /*
772 * Ensure the provided header's type matches the one registered to the
773 * stream class.
774 */
775 if (header) {
67d2ce02 776 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
16ca5ff0
PP
777 ((struct bt_ctf_field_common *) header)->type,
778 bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type) == 0,
312c056a 779 "Header field's type is different from the "
16ca5ff0
PP
780 "expected field type: event-addr=%p, ft-addr=%p, "
781 "expected-ft-addr=%p",
782 event, ((struct bt_ctf_field_common *) header)->type,
783 bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type);
312c056a 784 } else {
67d2ce02 785 BT_CTF_ASSERT_PRE(!bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type,
312c056a 786 "Setting no event header field, "
67d2ce02 787 "but event header field type is not NULL: "
16ca5ff0 788 "event-addr=%p, header-ft-addr=%p",
312c056a 789 event,
16ca5ff0 790 bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type);
312c056a
PP
791 }
792
e1e02a22
PP
793 bt_ctf_object_put_ref(event->common.header_field->field);
794 event->common.header_field->field = bt_ctf_object_get_ref(header);
ef267d12 795 BT_LOGT("Set event's header field: event-addr=%p, "
312c056a
PP
796 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
797 "header-field-addr=%p",
16ca5ff0
PP
798 event, bt_ctf_event_class_common_get_name(event->common.class),
799 bt_ctf_event_class_common_get_id(event->common.class), header);
312c056a
PP
800 return 0;
801}
802
803int bt_ctf_event_common_set_payload(struct bt_ctf_event *event,
804 struct bt_ctf_field *payload)
805{
67d2ce02
MJ
806 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
807 BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
312c056a
PP
808
809 if (payload) {
67d2ce02 810 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
16ca5ff0 811 ((struct bt_ctf_field_common *) payload)->type,
312c056a
PP
812 event->common.class->payload_field_type) == 0,
813 "Payload field's type is different from the "
16ca5ff0
PP
814 "expected field type: event-addr=%p, ft-addr=%p, "
815 "expected-ft-addr=%p",
312c056a 816 event,
16ca5ff0 817 ((struct bt_ctf_field_common *) payload)->type,
312c056a
PP
818 event->common.class->payload_field_type);
819 } else {
67d2ce02 820 BT_CTF_ASSERT_PRE(!event->common.class->payload_field_type,
312c056a 821 "Setting no event payload field, "
67d2ce02 822 "but event payload field type is not NULL: "
16ca5ff0 823 "event-addr=%p, payload-ft-addr=%p",
312c056a
PP
824 event, event->common.class->payload_field_type);
825 }
826
e1e02a22
PP
827 bt_ctf_object_put_ref(event->common.payload_field);
828 event->common.payload_field = bt_ctf_object_get_ref(payload);
ef267d12 829 BT_LOGT("Set event's payload field: event-addr=%p, "
312c056a
PP
830 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
831 "payload-field-addr=%p",
16ca5ff0
PP
832 event, bt_ctf_event_class_common_get_name(event->common.class),
833 bt_ctf_event_class_common_get_id(event->common.class), payload);
312c056a
PP
834 return 0;
835}
836
837int bt_ctf_event_set_context(struct bt_ctf_event *event,
838 struct bt_ctf_field *context)
839{
67d2ce02
MJ
840 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
841 BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
312c056a
PP
842
843 if (context) {
67d2ce02 844 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
16ca5ff0 845 ((struct bt_ctf_field_common *) context)->type,
312c056a
PP
846 event->common.class->context_field_type) == 0,
847 "Context field's type is different from the "
16ca5ff0
PP
848 "expected field type: event-addr=%p, ft-addr=%p, "
849 "expected-ft-addr=%p",
850 event, ((struct bt_ctf_field_common *) context)->type,
312c056a
PP
851 event->common.class->context_field_type);
852 } else {
67d2ce02 853 BT_CTF_ASSERT_PRE(!event->common.class->context_field_type,
312c056a 854 "Setting no event context field, "
67d2ce02 855 "but event context field type is not NULL: "
16ca5ff0 856 "event-addr=%p, context-ft-addr=%p",
312c056a
PP
857 event, event->common.class->context_field_type);
858 }
859
e1e02a22
PP
860 bt_ctf_object_put_ref(event->common.context_field);
861 event->common.context_field = bt_ctf_object_get_ref(context);
ef267d12 862 BT_LOGT("Set event's context field: event-addr=%p, "
312c056a
PP
863 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
864 "context-field-addr=%p",
16ca5ff0
PP
865 event, bt_ctf_event_class_common_get_name(event->common.class),
866 bt_ctf_event_class_common_get_id(event->common.class), context);
312c056a
PP
867 return 0;
868}
869
870int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
871 struct bt_ctf_field *stream_event_context)
872{
67d2ce02
MJ
873 BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
874 BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
312c056a
PP
875
876 if (stream_event_context) {
67d2ce02 877 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
16ca5ff0
PP
878 ((struct bt_ctf_field_common *) stream_event_context)->type,
879 bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type) == 0,
312c056a 880 "Stream event context field's type is different from the "
16ca5ff0
PP
881 "expected field type: event-addr=%p, ft-addr=%p, "
882 "expected-ft-addr=%p",
312c056a 883 event,
16ca5ff0
PP
884 ((struct bt_ctf_field_common *) stream_event_context)->type,
885 bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type);
312c056a 886 } else {
67d2ce02 887 BT_CTF_ASSERT_PRE(!bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type,
312c056a 888 "Setting no stream event context field, "
67d2ce02 889 "but stream event context field type is not NULL: "
16ca5ff0 890 "event-addr=%p, context-ft-addr=%p",
312c056a 891 event,
16ca5ff0 892 bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type);
312c056a
PP
893 }
894
e1e02a22
PP
895 bt_ctf_object_put_ref(event->common.stream_event_context_field);
896 event->common.stream_event_context_field = bt_ctf_object_get_ref(stream_event_context);
ef267d12 897 BT_LOGT("Set event's stream event context field: event-addr=%p, "
312c056a
PP
898 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
899 "stream-event-context-field-addr=%p",
16ca5ff0
PP
900 event, bt_ctf_event_class_common_get_name(event->common.class),
901 bt_ctf_event_class_common_get_id(event->common.class),
312c056a
PP
902 stream_event_context);
903 return 0;
904}
This page took 0.106473 seconds and 4 git commands to generate.