projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix writer: leak of the event classes
[babeltrace.git] / plugins / writer / write.c
CommitLineData
bc506aa5
JD		 1/*
2 * writer.c
3 *
4 * Babeltrace CTF Writer Output Plugin Event Handling
5 *
6 * Copyright 2016 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/event.h>
30#include <babeltrace/ctf-ir/packet.h>
31#include <babeltrace/ctf-ir/event-class.h>
32#include <babeltrace/ctf-ir/stream.h>
33#include <babeltrace/ctf-ir/stream-class.h>
ac0c6bdd 34#include <babeltrace/ctf-ir/clock-class.h>
bc506aa5
JD		 35#include <babeltrace/ctf-ir/fields.h>
36#include <babeltrace/ctf-writer/stream-class.h>
37#include <babeltrace/ctf-writer/stream.h>
38
39#include "writer.h"
40
bc506aa5 41static
ac0c6bdd 42enum bt_component_status copy_clock_class(FILE *err, struct bt_ctf_writer *writer,
bc506aa5 43 struct bt_ctf_stream_class *writer_stream_class,
ac0c6bdd 44 struct bt_ctf_clock_class *clock_class)
bc506aa5 45{
bc506aa5
JD		 46 int64_t offset, offset_s;
47 int int_ret;
48 uint64_t u64_ret;
49 const char *name, *description;
ac0c6bdd
PP		 50 struct bt_ctf_clock_class *writer_clock_class = NULL;
51 struct bt_ctf_trace *trace = NULL;
3241bc18 52 enum bt_component_status ret;
bc506aa5 53
ac0c6bdd 54 name = bt_ctf_clock_class_get_name(clock_class);
bc506aa5 55 if (!name) {
bc506aa5
JD		 56 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
57 __LINE__);
3241bc18 58 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 59 goto end;
60 }
61
ac0c6bdd
PP		 62 writer_clock_class = bt_ctf_clock_class_create(name);
63 if (!writer_clock_class) {
bc506aa5
JD		 64 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
65 __LINE__);
3241bc18 66 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 67 goto end;
68 }
69
ac0c6bdd 70 description = bt_ctf_clock_class_get_description(clock_class);
bc506aa5 71 if (!description) {
bc506aa5
JD		 72 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
73 __LINE__);
3241bc18 74 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 75 goto end_destroy;
76 }
77
ac0c6bdd 78 int_ret = bt_ctf_clock_class_set_description(writer_clock_class,
bc506aa5
JD		 79 description);
80 if (int_ret != 0) {
bc506aa5
JD		 81 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
82 __LINE__);
3241bc18 83 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 84 goto end_destroy;
85 }
86
ac0c6bdd 87 u64_ret = bt_ctf_clock_class_get_frequency(clock_class);
bc506aa5 88 if (u64_ret == -1ULL) {
bc506aa5
JD		 89 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
90 __LINE__);
3241bc18 91 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 92 goto end_destroy;
93 }
ac0c6bdd 94 int_ret = bt_ctf_clock_class_set_frequency(writer_clock_class, u64_ret);
bc506aa5 95 if (int_ret != 0) {
bc506aa5
JD		 96 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
97 __LINE__);
3241bc18 98 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 99 goto end_destroy;
100 }
101
ac0c6bdd 102 u64_ret = bt_ctf_clock_class_get_precision(clock_class);
bc506aa5 103 if (u64_ret == -1ULL) {
bc506aa5
JD		 104 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
105 __LINE__);
3241bc18 106 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 107 goto end_destroy;
108 }
ac0c6bdd
PP		 109 int_ret = bt_ctf_clock_class_set_precision(writer_clock_class,
110 u64_ret);
bc506aa5 111 if (int_ret != 0) {
bc506aa5
JD		 112 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
113 __LINE__);
3241bc18 114 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 115 goto end_destroy;
116 }
117
ac0c6bdd 118 int_ret = bt_ctf_clock_class_get_offset_s(clock_class, &offset_s);
bc506aa5 119 if (int_ret != 0) {
bc506aa5
JD		 120 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
121 __LINE__);
3241bc18 122 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 123 goto end_destroy;
124 }
125
ac0c6bdd 126 int_ret = bt_ctf_clock_class_set_offset_s(writer_clock_class, offset_s);
bc506aa5 127 if (int_ret != 0) {
bc506aa5
JD		 128 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
129 __LINE__);
3241bc18 130 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 131 goto end_destroy;
132 }
133
ac0c6bdd 134 int_ret = bt_ctf_clock_class_get_offset_cycles(clock_class, &offset);
bc506aa5 135 if (int_ret != 0) {
bc506aa5
JD		 136 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
137 __LINE__);
3241bc18 138 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 139 goto end_destroy;
140 }
141
ac0c6bdd 142 int_ret = bt_ctf_clock_class_set_offset_cycles(writer_clock_class, offset);
bc506aa5 143 if (int_ret != 0) {
bc506aa5
JD		 144 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
145 __LINE__);
3241bc18 146 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 147 goto end_destroy;
148 }
149
ac0c6bdd 150 int_ret = bt_ctf_clock_class_get_is_absolute(clock_class);
bc506aa5 151 if (int_ret == -1) {
bc506aa5
JD		 152 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
153 __LINE__);
3241bc18 154 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 155 goto end_destroy;
156 }
3241bc18 157
ac0c6bdd 158 int_ret = bt_ctf_clock_class_set_is_absolute(writer_clock_class, int_ret);
bc506aa5 159 if (int_ret != 0) {
bc506aa5
JD		 160 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
161 __LINE__);
bc506aa5 162 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 163 goto end_destroy;
164 }
165
ac0c6bdd
PP		 166 trace = bt_ctf_writer_get_trace(writer);
167 if (!trace) {
168 ret = BT_COMPONENT_STATUS_ERROR;
169 goto end_destroy;
170 }
171
172 int_ret = bt_ctf_trace_add_clock_class(trace, writer_clock_class);
3241bc18 173 if (int_ret != 0) {
bc506aa5
JD		 174 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
175 __LINE__);
3241bc18 176 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 177 goto end_destroy;
178 }
3241bc18 179
bc506aa5
JD		 180 /*
181 * Ownership transferred to the writer and the stream_class.
182 */
ac0c6bdd 183 bt_put(writer_clock_class);
bc506aa5 184 ret = BT_COMPONENT_STATUS_OK;
3241bc18 185
bc506aa5
JD		 186 goto end;
187
188end_destroy:
ac0c6bdd 189 BT_PUT(writer_clock_class);
bc506aa5 190end:
ac0c6bdd 191 BT_PUT(trace);
bc506aa5
JD		 192 return ret;
193}
194
195static
196struct bt_ctf_event_class *copy_event_class(FILE *err, struct bt_ctf_event_class *event_class)
197{
198 struct bt_ctf_event_class *writer_event_class = NULL;
199 const char *name;
200 struct bt_ctf_field_type *context;
201 int count, i, ret;
202
203 name = bt_ctf_event_class_get_name(event_class);
204 if (!name) {
205 fprintf(err, "[error] %s in %s:%d\n", __func__,
206 __FILE__, __LINE__);
207 goto end;
208 }
209
210 writer_event_class = bt_ctf_event_class_create(name);
211 if (!writer_event_class) {
212 fprintf(err, "[error] %s in %s:%d\n", __func__,
213 __FILE__, __LINE__);
214 goto end;
215 }
216
217 count = bt_ctf_event_class_get_attribute_count(event_class);
218 for (i = 0; i < count; i++) {
219 const char *attr_name;
220 struct bt_value *attr_value;
221 int ret;
222
223 attr_name = bt_ctf_event_class_get_attribute_name(event_class, i);
224 if (!attr_name) {
225 fprintf(err, "[error] %s in %s:%d\n", __func__,
226 __FILE__, __LINE__);
227 BT_PUT(writer_event_class);
228 goto end;
229 }
230 attr_value = bt_ctf_event_class_get_attribute_value(event_class, i);
231 if (!attr_value) {
232 fprintf(err, "[error] %s in %s:%d\n", __func__,
233 __FILE__, __LINE__);
234 BT_PUT(writer_event_class);
235 goto end;
236 }
237
238 ret = bt_ctf_event_class_set_attribute(writer_event_class,
239 attr_name, attr_value);
d00b90bf 240 bt_put(attr_value);
bc506aa5
JD		 241 if (ret < 0) {
242 fprintf(err, "[error] %s in %s:%d\n", __func__,
243 __FILE__, __LINE__);
244 BT_PUT(writer_event_class);
245 goto end;
246 }
247 }
248
249 context = bt_ctf_event_class_get_context_type(event_class);
bc506aa5 250 ret = bt_ctf_event_class_set_context_type(writer_event_class, context);
d00b90bf 251 bt_put(context);
bc506aa5
JD		 252 if (ret < 0) {
253 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
254 __LINE__);
255 goto end;
256 }
257
258 count = bt_ctf_event_class_get_field_count(event_class);
259 for (i = 0; i < count; i++) {
260 const char *field_name;
261 struct bt_ctf_field_type *field_type;
262 int ret;
263
264 ret = bt_ctf_event_class_get_field(event_class, &field_name,
265 &field_type, i);
266 if (ret < 0) {
267 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
268 BT_PUT(writer_event_class);
269 goto end;
270 }
271
272 ret = bt_ctf_event_class_add_field(writer_event_class, field_type,
273 field_name);
274 if (ret < 0) {
275 fprintf(err, "[error] Cannot add field %s\n", field_name);
276 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
277 bt_put(field_type);
278 BT_PUT(writer_event_class);
279 goto end;
280 }
281 bt_put(field_type);
282 }
283
284end:
285 return writer_event_class;
286}
287
288static
289enum bt_component_status copy_event_classes(FILE *err,
290 struct bt_ctf_writer *writer,
291 struct bt_ctf_stream_class *stream_class,
292 struct bt_ctf_stream_class *writer_stream_class)
293{
294 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
295 int count, i;
296
297 count = bt_ctf_stream_class_get_event_class_count(stream_class);
298 if (count < 0) {
299 fprintf(err, "[error] %s in %s:%d\n", __func__,
300 __FILE__, __LINE__);
301 goto end;
302 }
303
304 for (i = 0; i < count; i++) {
305 struct bt_ctf_event_class *event_class, *writer_event_class;
306 int int_ret;
307
308 event_class = bt_ctf_stream_class_get_event_class(
309 stream_class, i);
310 if (!event_class) {
311 fprintf(err, "[error] %s in %s:%d\n", __func__,
312 __FILE__, __LINE__);
313 ret = BT_COMPONENT_STATUS_ERROR;
314 bt_put(event_class);
315 goto end;
316 }
317 writer_event_class = copy_event_class(err, event_class);
318 if (!writer_event_class) {
319 fprintf(err, "[error] %s in %s:%d\n", __func__,
320 __FILE__, __LINE__);
321 ret = BT_COMPONENT_STATUS_ERROR;
322 bt_put(event_class);
323 goto end;
324 }
325 int_ret = bt_ctf_stream_class_add_event_class(writer_stream_class,
326 writer_event_class);
327 if (int_ret < 0) {
328 fprintf(err, "[error] Failed to add event class\n");
329 fprintf(err, "[error] %s in %s:%d\n", __func__,
330 __FILE__, __LINE__);
331 ret = BT_COMPONENT_STATUS_ERROR;
332 bt_put(event_class);
333 goto end;
334 }
335 bt_put(event_class);
1e0002d7 336 bt_put(writer_event_class);
bc506aa5
JD		 337 }
338
339end:
340 return ret;
341}
342
343static
344enum bt_component_status copy_stream_class(FILE *err,
345 struct bt_ctf_writer *writer,
346 struct bt_ctf_stream_class *stream_class,
347 struct bt_ctf_stream_class *writer_stream_class)
348{
349 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
350 struct bt_ctf_field_type *type;
ac0c6bdd 351 int ret_int, clock_class_count, i;
3241bc18 352 struct bt_ctf_trace *trace;
bc506aa5 353
3241bc18
JD		 354 trace = bt_ctf_stream_class_get_trace(stream_class);
355 if (!trace) {
bc506aa5
JD		 356 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
357 __LINE__);
3241bc18 358 ret = BT_COMPONENT_STATUS_ERROR;
bc506aa5
JD		 359 goto end;
360 }
361
ac0c6bdd 362 clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
bc506aa5 363
ac0c6bdd
PP		 364 for (i = 0; i < clock_class_count; i++) {
365 struct bt_ctf_clock_class *clock_class =
366 bt_ctf_trace_get_clock_class(trace, i);
3241bc18 367
ac0c6bdd 368 if (!clock_class) {
3241bc18
JD		 369 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
370 __LINE__);
371 ret = BT_COMPONENT_STATUS_ERROR;
372 goto end_put_trace;
373 }
374
ac0c6bdd
PP		 375 ret = copy_clock_class(err, writer, writer_stream_class, clock_class);
376 bt_put(clock_class);
3241bc18
JD		 377 if (ret != BT_COMPONENT_STATUS_OK) {
378 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
379 __LINE__);
380 goto end_put_trace;
381 }
bc506aa5 382 }
bc506aa5
JD		 383
384 type = bt_ctf_stream_class_get_packet_context_type(stream_class);
385 if (!type) {
386 ret = BT_COMPONENT_STATUS_ERROR;
387 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
388 __LINE__);
3241bc18 389 goto end_put_trace;
bc506aa5
JD		 390 }
391
392 ret_int = bt_ctf_stream_class_set_packet_context_type(
393 writer_stream_class, type);
d00b90bf 394 bt_put(type);
bc506aa5
JD		 395 if (ret_int < 0) {
396 ret = BT_COMPONENT_STATUS_ERROR;
397 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
398 __LINE__);
3241bc18 399 goto end_put_trace;
bc506aa5
JD		 400 }
401
402 type = bt_ctf_stream_class_get_event_header_type(stream_class);
403 if (!type) {
404 ret = BT_COMPONENT_STATUS_ERROR;
405 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
406 __LINE__);
3241bc18 407 goto end_put_trace;
bc506aa5
JD		 408 }
409
410 ret_int = bt_ctf_stream_class_set_event_header_type(
411 writer_stream_class, type);
d00b90bf 412 bt_put(type);
bc506aa5
JD		 413 if (ret_int < 0) {
414 ret = BT_COMPONENT_STATUS_ERROR;
415 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
416 __LINE__);
3241bc18 417 goto end_put_trace;
bc506aa5
JD		 418 }
419
420 type = bt_ctf_stream_class_get_event_context_type(stream_class);
d00b90bf
JD		 421 if (!type) {
422 ret = BT_COMPONENT_STATUS_ERROR;
423 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
424 __LINE__);
425 goto end_put_trace;
426 }
bc506aa5
JD		 427 ret_int = bt_ctf_stream_class_set_event_context_type(
428 writer_stream_class, type);
d00b90bf 429 bt_put(type);
bc506aa5
JD		 430 if (ret_int < 0) {
431 ret = BT_COMPONENT_STATUS_ERROR;
432 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
433 __LINE__);
3241bc18 434 goto end_put_trace;
bc506aa5
JD		 435 }
436
437 ret = copy_event_classes(err, writer, stream_class, writer_stream_class);
438 if (ret != BT_COMPONENT_STATUS_OK) {
439 fprintf(err, "[error] Failed to copy event classes\n");
440 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
441 __LINE__);
3241bc18 442 goto end_put_trace;
bc506aa5
JD		 443 }
444
3241bc18
JD		 445end_put_trace:
446 bt_put(trace);
bc506aa5
JD		 447end:
448 return ret;
449}
450
451static
452enum bt_component_status copy_trace(FILE *err, struct bt_ctf_writer *ctf_writer,
453 struct bt_ctf_trace *trace)
454{
455 struct bt_ctf_trace *writer_trace;
456 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
457 int field_count, i, int_ret;
458 struct bt_ctf_field_type *header_type;
459
460 writer_trace = bt_ctf_writer_get_trace(ctf_writer);
461 if (!writer_trace) {
462 ret = BT_COMPONENT_STATUS_ERROR;
463 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
464 __LINE__);
465 goto end;
466 }
467
468 field_count = bt_ctf_trace_get_environment_field_count(trace);
469 for (i = 0; i < field_count; i++) {
470 int ret_int;
471 const char *name;
472 struct bt_value *value;
473
474 name = bt_ctf_trace_get_environment_field_name(trace, i);
475 if (!name) {
476 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
477 __LINE__);
478 ret = BT_COMPONENT_STATUS_ERROR;
479 goto end_put_writer_trace;
480 }
481 value = bt_ctf_trace_get_environment_field_value(trace, i);
482 if (!value) {
483 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
484 __LINE__);
485 ret = BT_COMPONENT_STATUS_ERROR;
486 goto end_put_writer_trace;
487 }
488
489 ret_int = bt_ctf_trace_set_environment_field(writer_trace,
490 name, value);
d00b90bf 491 bt_put(value);
bc506aa5
JD		 492 if (ret_int < 0) {
493 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
494 __LINE__);
495 fprintf(err, "[error] Unable to set environment field %s\n",
496 name);
497 ret = BT_COMPONENT_STATUS_ERROR;
498 goto end_put_writer_trace;
499 }
500 }
501
502 header_type = bt_ctf_trace_get_packet_header_type(writer_trace);
503 if (!header_type) {
504 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
505 ret = BT_COMPONENT_STATUS_ERROR;
506 goto end_put_writer_trace;
507 }
508
509 int_ret = bt_ctf_trace_set_packet_header_type(writer_trace, header_type);
510 if (int_ret < 0) {
511 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
512 ret = BT_COMPONENT_STATUS_ERROR;
513 goto end_put_header_type;
514 }
515
516end_put_header_type:
517 bt_put(header_type);
518end_put_writer_trace:
519 bt_put(writer_trace);
520end:
521 return ret;
522}
523
524static
525struct bt_ctf_stream_class *insert_new_stream_class(
526 struct writer_component *writer_component,
527 struct bt_ctf_writer *ctf_writer,
528 struct bt_ctf_stream_class *stream_class)
529{
530 struct bt_ctf_stream_class *writer_stream_class;
531 const char *name = bt_ctf_stream_class_get_name(stream_class);
532 enum bt_component_status ret;
533
534 if (strlen(name) == 0) {
535 name = NULL;
536 }
537
538 writer_stream_class = bt_ctf_stream_class_create(name);
539 if (!writer_stream_class) {
540 fprintf(writer_component->err, "[error] %s in %s:%d\n",
541 __func__, __FILE__, __LINE__);
542 goto end;
543 }
544
545 ret = copy_stream_class(writer_component->err,
546 ctf_writer, stream_class, writer_stream_class);
547 if (ret != BT_COMPONENT_STATUS_OK) {
548 fprintf(writer_component->err, "[error] Failed to copy stream class\n");
549 fprintf(writer_component->err, "[error] %s in %s:%d\n",
550 __func__, __FILE__, __LINE__);
551 BT_PUT(writer_stream_class);
552 goto end;
553 }
554 g_hash_table_insert(writer_component->stream_class_map,
555 (gpointer) stream_class, writer_stream_class);
556
557end:
558 return writer_stream_class;
559}
560
561static
562struct bt_ctf_stream *insert_new_stream(
563 struct writer_component *writer_component,
564 struct bt_ctf_writer *ctf_writer,
565 struct bt_ctf_stream_class *stream_class,
566 struct bt_ctf_stream *stream)
567{
568 struct bt_ctf_stream *writer_stream;
569 struct bt_ctf_stream_class *writer_stream_class;
570
571 writer_stream_class = g_hash_table_lookup(
572 writer_component->stream_class_map,
573 (gpointer) stream_class);
574 if (writer_stream_class) {
575 if (!bt_get(writer_stream_class)) {
576 writer_stream = NULL;
577 fprintf(writer_component->err, "[error] %s in %s:%d\n",
578 __func__, __FILE__, __LINE__);
579 goto end;
580 }
581 } else {
582 writer_stream_class = insert_new_stream_class(
583 writer_component, ctf_writer, stream_class);
584 if (!writer_stream_class) {
585 writer_stream = NULL;
586 fprintf(writer_component->err, "[error] %s in %s:%d\n",
587 __func__, __FILE__, __LINE__);
588 goto end_put;
589 }
590 }
591
592 writer_stream = bt_ctf_writer_create_stream(ctf_writer,
593 writer_stream_class);
594 if (!writer_stream) {
595 fprintf(writer_component->err, "[error] %s in %s:%d\n",
596 __func__, __FILE__, __LINE__);
597 goto end_put;
598 }
599
600 g_hash_table_insert(writer_component->stream_map, (gpointer) stream,
601 writer_stream);
602
603 bt_ctf_writer_flush_metadata(ctf_writer);
604
605end_put:
606 bt_put(writer_stream_class);
607end:
608 return writer_stream;
609}
610
611static
612struct bt_ctf_stream *lookup_stream(struct writer_component *writer_component,
613 struct bt_ctf_stream *stream)
614{
615 return (struct bt_ctf_stream *) g_hash_table_lookup(
616 writer_component->stream_map,
617 (gpointer) stream);
618}
619
620static
621struct bt_ctf_event_class *get_event_class(struct writer_component *writer_component,
622 struct bt_ctf_stream_class *writer_stream_class,
623 struct bt_ctf_event_class *event_class)
624{
625 return bt_ctf_stream_class_get_event_class_by_name(writer_stream_class,
626 bt_ctf_event_class_get_name(event_class));
627}
628
629struct bt_ctf_writer *insert_new_writer(
630 struct writer_component *writer_component,
631 struct bt_ctf_trace *trace)
632{
633 struct bt_ctf_writer *ctf_writer;
634 char trace_name[PATH_MAX];
635 enum bt_component_status ret;
636
637 snprintf(trace_name, PATH_MAX, "%s/%s_%03d",
9057f037
JD		 638 writer_component->base_path->str,
639 writer_component->trace_name_base->str,
bc506aa5
JD		 640 writer_component->trace_id++);
641 printf_verbose("CTF-Writer creating trace in %s\n", trace_name);
9057f037 642
bc506aa5
JD		 643 ctf_writer = bt_ctf_writer_create(trace_name);
644 if (!ctf_writer) {
645 fprintf(writer_component->err, "[error] %s in %s:%d\n",
646 __func__, __FILE__, __LINE__);
647 goto end;
648 }
649
650 ret = copy_trace(writer_component->err, ctf_writer, trace);
651 if (ret != BT_COMPONENT_STATUS_OK) {
652 fprintf(writer_component->err, "[error] Failed to copy trace\n");
653 fprintf(writer_component->err, "[error] %s in %s:%d\n",
654 __func__, __FILE__, __LINE__);
655 BT_PUT(ctf_writer);
656 goto end;
657 }
658
659 g_hash_table_insert(writer_component->trace_map, (gpointer) trace,
660 ctf_writer);
661
662end:
663 return ctf_writer;
664}
665
666static
667struct bt_ctf_writer *get_writer(struct writer_component *writer_component,
668 struct bt_ctf_stream_class *stream_class)
669{
670 struct bt_ctf_trace *trace;
671 struct bt_ctf_writer *ctf_writer;
672
673 trace = bt_ctf_stream_class_get_trace(stream_class);
674 if (!trace) {
675 ctf_writer = NULL;
676 fprintf(writer_component->err, "[error] %s in %s:%d\n",
677 __func__, __FILE__, __LINE__);
678 goto end;
679 }
680
681 ctf_writer = g_hash_table_lookup(writer_component->trace_map,
682 (gpointer) trace);
683 if (ctf_writer) {
684 if (!bt_get(ctf_writer)) {
685 ctf_writer = NULL;
686 fprintf(writer_component->err, "[error] %s in %s:%d\n",
687 __func__, __FILE__, __LINE__);
688 goto end;
689 }
690 } else {
691 ctf_writer = insert_new_writer(writer_component, trace);
692 }
693 bt_put(trace);
694
695end:
696 return ctf_writer;
697}
698
699static
700struct bt_ctf_stream *get_writer_stream(
701 struct writer_component *writer_component,
702 struct bt_ctf_packet *packet, struct bt_ctf_stream *stream)
703{
704 struct bt_ctf_stream_class *stream_class;
705 struct bt_ctf_writer *ctf_writer;
706 struct bt_ctf_stream *writer_stream;
707
708 stream_class = bt_ctf_stream_get_class(stream);
709 if (!stream_class) {
710 writer_stream = NULL;
711 fprintf(writer_component->err, "[error] %s in %s:%d\n",
712 __func__, __FILE__, __LINE__);
713 goto end;
714 }
715
716 ctf_writer = get_writer(writer_component, stream_class);
717 if (!ctf_writer) {
718 writer_stream = NULL;
719 fprintf(writer_component->err, "[error] %s in %s:%d\n",
720 __func__, __FILE__, __LINE__);
721 goto end_put_stream_class;
722 }
723
724 writer_stream = lookup_stream(writer_component, stream);
725
726 if (writer_stream) {
727 if (!bt_get(writer_stream)) {
728 writer_stream = NULL;
729 fprintf(writer_component->err, "[error] %s in %s:%d\n",
730 __func__, __FILE__, __LINE__);
731 goto end_put_stream_class;
732 }
733 } else {
734 writer_stream = insert_new_stream(writer_component, ctf_writer,
735 stream_class, stream);
1e0002d7 736 bt_get(writer_stream);
bc506aa5
JD		 737 }
738
739 bt_put(ctf_writer);
740end_put_stream_class:
741 bt_put(stream_class);
742end:
743 return writer_stream;
744}
745
746BT_HIDDEN
747enum bt_component_status writer_new_packet(
748 struct writer_component *writer_component,
749 struct bt_ctf_packet *packet)
750{
751 struct bt_ctf_stream *stream, *writer_stream;
752 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
753
754 stream = bt_ctf_packet_get_stream(packet);
755 if (!stream) {
756 ret = BT_COMPONENT_STATUS_ERROR;
757 fprintf(writer_component->err, "[error] %s in %s:%d\n",
758 __func__, __FILE__, __LINE__);
759 goto end;
760 }
761
762 /* TODO: copy values for event discarded and packet_seq_num */
763 writer_stream = get_writer_stream(writer_component, packet, stream);
764 if (!writer_stream) {
765 ret = BT_COMPONENT_STATUS_ERROR;
766 fprintf(writer_component->err, "[error] %s in %s:%d\n",
767 __func__, __FILE__, __LINE__);
768 goto end_put;
769 }
770
771 bt_put(writer_stream);
772
773end_put:
774 bt_put(stream);
775end:
776 return ret;
777}
778
779static
780enum bt_component_status copy_packet_context_field(FILE *err,
781 struct bt_ctf_field *field, const char *field_name,
782 struct bt_ctf_field *writer_packet_context,
783 struct bt_ctf_field_type *writer_packet_context_type)
784{
785 enum bt_component_status ret;
786 struct bt_ctf_field *writer_field;
787 int int_ret;
788 uint64_t value;
789
790 /*
791 * TODO: handle the special case of the first/last packet that might
792 * be trimmed. In these cases, the timestamp_begin/end need to be
793 * explicitely set to the first/last event timestamps.
794 */
795
796 writer_field = bt_ctf_field_structure_get_field(writer_packet_context,
797 field_name);
798 if (!writer_field) {
799 ret = BT_COMPONENT_STATUS_ERROR;
800 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
801 __LINE__);
802 goto end;
803 }
804
805 int_ret = bt_ctf_field_unsigned_integer_get_value(field, &value);
806 if (int_ret < 0) {
807 fprintf(err, "[error] Wrong packet_context field type\n");
808 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
809 __LINE__);
810 ret = BT_COMPONENT_STATUS_ERROR;
811 goto end_put_writer_field;
812 }
813
814 int_ret = bt_ctf_field_unsigned_integer_set_value(writer_field, value);
815 if (int_ret < 0) {
816 ret = BT_COMPONENT_STATUS_ERROR;
817 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
818 __LINE__);
819 goto end_put_writer_field;
820 }
821
822 ret = BT_COMPONENT_STATUS_OK;
823
824end_put_writer_field:
825 bt_put(writer_field);
826end:
827 return ret;
828}
829
830static
831enum bt_component_status copy_packet_context(FILE *err,
832 struct bt_ctf_packet *packet,
833 struct bt_ctf_stream *writer_stream)
834{
835 enum bt_component_status ret;
836 struct bt_ctf_field *packet_context, *writer_packet_context;
837 struct bt_ctf_field_type *struct_type, *writer_packet_context_type;
838 struct bt_ctf_stream_class *writer_stream_class;
839 int nr_fields, i, int_ret;
840
841 packet_context = bt_ctf_packet_get_context(packet);
842 if (!packet_context) {
843 ret = BT_COMPONENT_STATUS_ERROR;
844 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
845 __LINE__);
846 goto end;
847 }
848
849 writer_stream_class = bt_ctf_stream_get_class(writer_stream);
850 if (!writer_stream_class) {
851 ret = BT_COMPONENT_STATUS_ERROR;
852 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
853 __LINE__);
854 goto end_put_packet_context;
855 }
856
857 writer_packet_context_type = bt_ctf_stream_class_get_packet_context_type(
858 writer_stream_class);
859 if (!writer_packet_context_type) {
860 ret = BT_COMPONENT_STATUS_ERROR;
861 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
862 __LINE__);
863 goto end_put_writer_stream_class;
864 }
865
866 struct_type = bt_ctf_field_get_type(packet_context);
867 if (!struct_type) {
868 ret = BT_COMPONENT_STATUS_ERROR;
869 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
870 __LINE__);
871 goto end_put_writer_packet_context_type;
872 }
873
874 writer_packet_context = bt_ctf_field_create(writer_packet_context_type);
875 if (!writer_packet_context) {
876 ret = BT_COMPONENT_STATUS_ERROR;
877 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
878 __LINE__);
879 goto end_put_struct_type;
880 }
881
882 nr_fields = bt_ctf_field_type_structure_get_field_count(struct_type);
883 for (i = 0; i < nr_fields; i++) {
884 struct bt_ctf_field *field;
885 struct bt_ctf_field_type *field_type;
886 const char *field_name;
887
888 field = bt_ctf_field_structure_get_field_by_index(
889 packet_context, i);
890 if (!field) {
891 ret = BT_COMPONENT_STATUS_ERROR;
892 fprintf(err, "[error] %s in %s:%d\n", __func__,
893 __FILE__, __LINE__);
894 goto end_put_writer_packet_context;
895 }
896 if (bt_ctf_field_type_structure_get_field(struct_type,
897 &field_name, &field_type, i) < 0) {
898 ret = BT_COMPONENT_STATUS_ERROR;
899 bt_put(field);
900 fprintf(err, "[error] %s in %s:%d\n", __func__,
901 __FILE__, __LINE__);
902 goto end_put_writer_packet_context;
903 }
904
905 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_TYPE_ID_INTEGER) {
906 fprintf(err, "[error] Unexpected packet context field type\n");
907 bt_put(field);
908 ret = BT_COMPONENT_STATUS_ERROR;
909 goto end_put_writer_packet_context;
910 }
911
912 ret = copy_packet_context_field(err, field, field_name,
913 writer_packet_context, writer_packet_context_type);
914 bt_put(field_type);
915 bt_put(field);
916 if (ret != BT_COMPONENT_STATUS_OK) {
917 fprintf(err, "[error] %s in %s:%d\n", __func__,
918 __FILE__, __LINE__);
919 goto end_put_writer_packet_context;
920 }
921 }
922
923 int_ret = bt_ctf_stream_set_packet_context(writer_stream,
924 writer_packet_context);
925 if (int_ret < 0) {
926 ret = BT_COMPONENT_STATUS_ERROR;
927 goto end_put_writer_packet_context;
928 }
929
930end_put_writer_packet_context:
931 bt_put(writer_packet_context);
932end_put_struct_type:
933 bt_put(struct_type);
934end_put_writer_packet_context_type:
935 bt_put(writer_packet_context_type);
936end_put_writer_stream_class:
937 bt_put(writer_stream_class);
938end_put_packet_context:
939 bt_put(packet_context);
940end:
941 return ret;
942}
943
944BT_HIDDEN
945enum bt_component_status writer_close_packet(
946 struct writer_component *writer_component,
947 struct bt_ctf_packet *packet)
948{
949 struct bt_ctf_stream *stream, *writer_stream;
950 enum bt_component_status ret;
951
952 stream = bt_ctf_packet_get_stream(packet);
953 if (!stream) {
954 ret = BT_COMPONENT_STATUS_ERROR;
955 fprintf(writer_component->err, "[error] %s in %s:%d\n",
956 __func__, __FILE__, __LINE__);
957 goto end;
958 }
959
960 writer_stream = lookup_stream(writer_component, stream);
961 if (!writer_stream) {
962 ret = BT_COMPONENT_STATUS_ERROR;
963 fprintf(writer_component->err, "[error] %s in %s:%d\n",
964 __func__, __FILE__, __LINE__);
965 goto end_put;
966 }
967
968 if (!bt_get(writer_stream)) {
969 fprintf(writer_component->err,
970 "[error] Failed to get reference on writer stream\n");
971 fprintf(writer_component->err, "[error] %s in %s:%d\n",
972 __func__, __FILE__, __LINE__);
973 ret = BT_COMPONENT_STATUS_ERROR;
974 goto end_put;
975 }
976
977 ret = copy_packet_context(writer_component->err, packet, writer_stream);
978 if (ret != BT_COMPONENT_STATUS_OK) {
979 ret = BT_COMPONENT_STATUS_ERROR;
980 fprintf(writer_component->err, "[error] %s in %s:%d\n",
981 __func__, __FILE__, __LINE__);
982 goto end_put;
983 }
984
985 ret = bt_ctf_stream_flush(writer_stream);
986 if (ret < 0) {
987 fprintf(writer_component->err,
988 "[error] Failed to flush packet\n");
989 ret = BT_COMPONENT_STATUS_ERROR;
990 }
991
992 ret = BT_COMPONENT_STATUS_OK;
993
994 bt_put(writer_stream);
995
996end_put:
997 bt_put(stream);
998end:
999 return ret;
1000}
1001
1002static
1003struct bt_ctf_event *copy_event(FILE *err, struct bt_ctf_event *event,
1004 struct bt_ctf_event_class *writer_event_class)
1005{
1006 struct bt_ctf_event *writer_event;
01972692 1007 struct bt_ctf_field *field, *copy_field;
bc506aa5
JD		 1008 int ret;
1009
1010 writer_event = bt_ctf_event_create(writer_event_class);
1011 if (!writer_event) {
01972692
JD		 1012 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1013 __LINE__);
bc506aa5
JD		 1014 goto end;
1015 }
1016
1017 field = bt_ctf_event_get_header(event);
01972692 1018 if (!field) {
bc506aa5 1019 BT_PUT(writer_event);
01972692
JD		 1020 fprintf(err, "[error] %s in %s:%d\n", __func__,
1021 __FILE__, __LINE__);
bc506aa5
JD		 1022 goto end;
1023 }
01972692
JD		 1024 copy_field = bt_ctf_field_copy(field);
1025 bt_put(field);
1026 if (copy_field) {
1027 ret = bt_ctf_event_set_header(writer_event, copy_field);
1028 if (ret < 0) {
1029 fprintf(err, "[error] %s in %s:%d\n", __func__,
1030 __FILE__, __LINE__);
1031 goto error;
1032 }
1033 bt_put(copy_field);
1034 }
bc506aa5 1035
01972692 1036 /* Optional field, so it can fail silently. */
bc506aa5 1037 field = bt_ctf_event_get_stream_event_context(event);
01972692
JD		 1038 copy_field = bt_ctf_field_copy(field);
1039 bt_put(field);
1040 if (copy_field) {
1041 ret = bt_ctf_event_set_stream_event_context(writer_event,
1042 copy_field);
1043 if (ret < 0) {
1044 fprintf(err, "[error] %s in %s:%d\n", __func__,
1045 __FILE__, __LINE__);
1046 goto error;
1047 }
1048 bt_put(copy_field);
bc506aa5
JD		 1049 }
1050
01972692 1051 /* Optional field, so it can fail silently. */
bc506aa5 1052 field = bt_ctf_event_get_event_context(event);
01972692
JD		 1053 copy_field = bt_ctf_field_copy(field);
1054 bt_put(field);
1055 if (copy_field) {
1056 ret = bt_ctf_event_set_event_context(writer_event, copy_field);
1057 if (ret < 0) {
1058 fprintf(err, "[error] %s in %s:%d\n", __func__,
1059 __FILE__, __LINE__);
1060 goto error;
1061 }
1062 bt_put(copy_field);
bc506aa5
JD		 1063 }
1064
1065 field = bt_ctf_event_get_payload_field(event);
01972692 1066 if (!field) {
bc506aa5 1067 BT_PUT(writer_event);
01972692
JD		 1068 fprintf(err, "[error] %s in %s:%d\n", __func__,
1069 __FILE__, __LINE__);
bc506aa5
JD		 1070 goto end;
1071 }
01972692
JD		 1072 copy_field = bt_ctf_field_copy(field);
1073 bt_put(field);
1074 if (copy_field) {
1075 ret = bt_ctf_event_set_payload_field(writer_event, copy_field);
1076 if (ret < 0) {
1077 fprintf(err, "[error] %s in %s:%d\n", __func__,
1078 __FILE__, __LINE__);
1079 goto error;
1080 }
1081 bt_put(copy_field);
1082 }
1083 goto end;
bc506aa5 1084
01972692
JD		 1085error:
1086 bt_put(copy_field);
1087 BT_PUT(writer_event);
bc506aa5
JD		 1088end:
1089 return writer_event;
1090}
1091
1092BT_HIDDEN
1093enum bt_component_status writer_output_event(
1094 struct writer_component *writer_component,
1095 struct bt_ctf_event *event)
1096{
1097 enum bt_component_status ret;
1098 struct bt_ctf_event_class *event_class, *writer_event_class;
1099 struct bt_ctf_stream *stream, *writer_stream;
1100 struct bt_ctf_stream_class *stream_class, *writer_stream_class;
1101 struct bt_ctf_event *writer_event;
1102 const char *event_name;
1103 int int_ret;
1104
1105 event_class = bt_ctf_event_get_class(event);
1106 if (!event_class) {
1107 ret = BT_COMPONENT_STATUS_ERROR;
1108 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1109 __FILE__, __LINE__);
1110 goto end;
1111 }
1112
1113 event_name = bt_ctf_event_class_get_name(event_class);
1114 if (!event_name) {
1115 ret = BT_COMPONENT_STATUS_ERROR;
1116 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1117 __FILE__, __LINE__);
1118 goto end_put_event_class;
1119 }
bc506aa5
JD		 1120
1121 stream = bt_ctf_event_get_stream(event);
1122 if (!stream) {
1123 ret = BT_COMPONENT_STATUS_ERROR;
1124 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1125 __FILE__, __LINE__);
1126 goto end_put_event_class;
1127 }
1128
1129 writer_stream = lookup_stream(writer_component, stream);
1130 if (!writer_stream || !bt_get(writer_stream)) {
1131 ret = BT_COMPONENT_STATUS_ERROR;
1132 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1133 __FILE__, __LINE__);
1134 goto end_put_stream;
1135 }
1136
1137 stream_class = bt_ctf_event_class_get_stream_class(event_class);
1138 if (!stream_class) {
1139 ret = BT_COMPONENT_STATUS_ERROR;
1140 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1141 __FILE__, __LINE__);
1142 goto end_put_writer_stream;
1143 }
1144
1145 writer_stream_class = g_hash_table_lookup(
1146 writer_component->stream_class_map,
1147 (gpointer) stream_class);
1148 if (!writer_stream_class || !bt_get(writer_stream_class)) {
1149 ret = BT_COMPONENT_STATUS_ERROR;
1150 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1151 __FILE__, __LINE__);
1152 goto end_put_stream_class;
1153 }
1154
1155 writer_event_class = get_event_class(writer_component,
1156 writer_stream_class, event_class);
1157 if (!writer_event_class) {
1158 ret = BT_COMPONENT_STATUS_ERROR;
1159 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1160 __FILE__, __LINE__);
1161 goto end_put_writer_stream_class;
1162 }
1163
1164 writer_event = copy_event(writer_component->err, event, writer_event_class);
1165 if (!writer_event) {
1166 ret = BT_COMPONENT_STATUS_ERROR;
1167 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1168 __FILE__, __LINE__);
1169 fprintf(writer_component->err, "[error] Failed to copy event %s\n",
1170 bt_ctf_event_class_get_name(writer_event_class));
1171 goto end_put_writer_event_class;
1172 }
1173
1174 int_ret = bt_ctf_stream_append_event(writer_stream, writer_event);
1175 if (int_ret < 0) {
1176 ret = BT_COMPONENT_STATUS_ERROR;
1177 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1178 __FILE__, __LINE__);
1179 fprintf(writer_component->err, "[error] Failed to append event %s\n",
1180 bt_ctf_event_class_get_name(writer_event_class));
1181 goto end_put_writer_event;
1182 }
1183
1184 ret = BT_COMPONENT_STATUS_OK;
1185
1186end_put_writer_event:
1187 bt_put(writer_event);
1188end_put_writer_event_class:
1189 bt_put(writer_event_class);
1190end_put_writer_stream_class:
1191 bt_put(writer_stream_class);
1192end_put_stream_class:
1193 bt_put(stream_class);
1194end_put_writer_stream:
1195 bt_put(writer_stream);
1196end_put_stream:
1197 bt_put(stream);
1198end_put_event_class:
1199 bt_put(event_class);
1200end:
1201 return ret;
1202}
BabelTrace - Trace Format Babel Tower
This page took 0.071023 seconds and 4 git commands to generate.