projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: add_clock_classes(): do not add existing clock classes
[babeltrace.git] / plugins / lttng-utils / copy.c
CommitLineData
4f45f9bb
JD		 1/*
2 * copy.c
3 *
4 * Babeltrace Copy Trace Structure
5 *
6 * Copyright 2017 Julien Desfossez <jdesfossez@efficios.com>
7 *
8 * Author: Julien Desfossez <jdesfossez@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 <inttypes.h>
30#include <babeltrace/ctf-ir/event.h>
31#include <babeltrace/ctf-ir/packet.h>
32#include <babeltrace/ctf-ir/event-class.h>
33#include <babeltrace/ctf-ir/stream.h>
34#include <babeltrace/ctf-ir/stream-class.h>
35#include <babeltrace/ctf-ir/clock-class.h>
36#include <babeltrace/ctf-ir/fields.h>
37#include <babeltrace/ctf-writer/stream-class.h>
38#include <babeltrace/ctf-writer/stream.h>
39
40#include <ctfcopytrace.h>
41#include "debug-info.h"
42
cb0a5cf8
JD		 43static
44struct bt_ctf_stream *insert_new_stream(
45 struct debug_info_iterator *debug_it,
46 struct bt_ctf_stream *stream,
47 struct debug_info_trace *di_trace);
48
504db471
JD		 49static
50void unref_stream(struct bt_ctf_stream *stream)
51{
52 bt_put(stream);
53}
54
55static
56void unref_packet(struct bt_ctf_packet *packet)
57{
58 bt_put(packet);
59}
60
61static
62void unref_stream_class(struct bt_ctf_stream_class *stream_class)
63{
64 bt_put(stream_class);
65}
66
67static
68void unref_debug_info(struct debug_info *debug_info)
69{
70 debug_info_destroy(debug_info);
71}
72
1c78e839
JD		 73static
74void destroy_stream_state_key(gpointer key)
75{
76 g_free((enum fs_writer_stream_state *) key);
77}
78
4f45f9bb
JD		 79static
80struct bt_ctf_field *get_payload_field(FILE *err,
81 struct bt_ctf_event *event, const char *field_name)
82{
83 struct bt_ctf_field *field = NULL, *sec = NULL;
84 struct bt_ctf_field_type *sec_type = NULL;
85
86 sec = bt_ctf_event_get_payload(event, NULL);
87 if (!sec) {
88 fprintf(err, "[error] %s in %s:%d\n", __func__,
89 __FILE__, __LINE__);
90 goto end;
91 }
92
93 sec_type = bt_ctf_field_get_type(sec);
94 if (!sec_type) {
95 fprintf(err, "[error] %s in %s:%d\n", __func__,
96 __FILE__, __LINE__);
97 goto end;
98 }
99
1487a16a 100 if (bt_ctf_field_type_get_type_id(sec_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
4f45f9bb
JD		 101 fprintf(err, "[error] %s in %s:%d\n", __func__,
102 __FILE__, __LINE__);
103 goto end;
104 }
105
106 field = bt_ctf_field_structure_get_field(sec, field_name);
107
108end:
109 bt_put(sec_type);
110 bt_put(sec);
111 return field;
112}
113
114static
115struct bt_ctf_field *get_stream_event_context_field(FILE *err,
116 struct bt_ctf_event *event, const char *field_name)
117{
118 struct bt_ctf_field *field = NULL, *sec = NULL;
119 struct bt_ctf_field_type *sec_type = NULL;
120
121 sec = bt_ctf_event_get_stream_event_context(event);
122 if (!sec) {
4f45f9bb
JD		 123 goto end;
124 }
125
126 sec_type = bt_ctf_field_get_type(sec);
127 if (!sec_type) {
128 fprintf(err, "[error] %s in %s:%d\n", __func__,
129 __FILE__, __LINE__);
130 goto end;
131 }
132
1487a16a 133 if (bt_ctf_field_type_get_type_id(sec_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
4f45f9bb
JD		 134 fprintf(err, "[error] %s in %s:%d\n", __func__,
135 __FILE__, __LINE__);
136 goto end;
137 }
138
139 field = bt_ctf_field_structure_get_field(sec, field_name);
140
141end:
142 bt_put(sec_type);
143 bt_put(sec);
144 return field;
145}
146
147BT_HIDDEN
148int get_stream_event_context_unsigned_int_field_value(FILE *err,
149 struct bt_ctf_event *event, const char *field_name,
150 uint64_t *value)
151{
152 int ret;
153 struct bt_ctf_field *field = NULL;
154 struct bt_ctf_field_type *field_type = NULL;
155
156 field = get_stream_event_context_field(err, event, field_name);
157 if (!field) {
4f45f9bb
JD		 158 goto error;
159 }
160
161 field_type = bt_ctf_field_get_type(field);
162 if (!field_type) {
163 fprintf(err, "[error] %s in %s:%d\n", __func__,
164 __FILE__, __LINE__);
165 goto error;
166 }
167
1487a16a 168 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
4f45f9bb
JD		 169 fprintf(err, "[error] %s in %s:%d\n", __func__,
170 __FILE__, __LINE__);
171 goto error;
172 }
173
174 if (bt_ctf_field_type_integer_get_signed(field_type) != 0) {
175 fprintf(err, "[error] %s in %s:%d\n", __func__,
176 __FILE__, __LINE__);
177 goto error;
178 }
179
180 ret = bt_ctf_field_unsigned_integer_get_value(field, value);
181 goto end;
182
183error:
184 ret = -1;
185end:
186 bt_put(field_type);
187 bt_put(field);
188 return ret;
189}
190
191BT_HIDDEN
192int get_stream_event_context_int_field_value(FILE *err, struct bt_ctf_event *event,
193 const char *field_name, int64_t *value)
194{
195 struct bt_ctf_field *field = NULL;
196 struct bt_ctf_field_type *field_type = NULL;
197 int ret;
198
199 field = get_stream_event_context_field(err, event, field_name);
200 if (!field) {
201 goto error;
202 }
203
204 field_type = bt_ctf_field_get_type(field);
205 if (!field_type) {
206 fprintf(err, "[error] %s in %s:%d\n", __func__,
207 __FILE__, __LINE__);
208 goto error;
209 }
210
1487a16a 211 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
4f45f9bb
JD		 212 fprintf(err, "[error] %s in %s:%d\n", __func__,
213 __FILE__, __LINE__);
214 goto error;
215 }
216
217 if (bt_ctf_field_type_integer_get_signed(field_type) != 1) {
218 fprintf(err, "[error] %s in %s:%d\n", __func__,
219 __FILE__, __LINE__);
220 goto error;
221 }
222
223 ret = bt_ctf_field_signed_integer_get_value(field, value);
224 goto end;
225
226error:
227 ret = -1;
228end:
229 bt_put(field_type);
230 bt_put(field);
231 return ret;
232}
233
234BT_HIDDEN
235int get_payload_unsigned_int_field_value(FILE *err,
236 struct bt_ctf_event *event, const char *field_name,
237 uint64_t *value)
238{
239 struct bt_ctf_field *field = NULL;
240 struct bt_ctf_field_type *field_type = NULL;
241 int ret;
242
243 field = get_payload_field(err, event, field_name);
244 if (!field) {
245 fprintf(err, "[error] %s in %s:%d\n", __func__,
246 __FILE__, __LINE__);
247 goto error;
248 }
249
250 field_type = bt_ctf_field_get_type(field);
251 if (!field_type) {
252 fprintf(err, "[error] %s in %s:%d\n", __func__,
253 __FILE__, __LINE__);
254 goto error;
255 }
256
1487a16a 257 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
4f45f9bb
JD		 258 fprintf(err, "[error] %s in %s:%d\n", __func__,
259 __FILE__, __LINE__);
260 goto error;
261 }
262
263 if (bt_ctf_field_type_integer_get_signed(field_type) != 0) {
264 fprintf(err, "[error] %s in %s:%d\n", __func__,
265 __FILE__, __LINE__);
266 goto error;
267 }
268
269 ret = bt_ctf_field_unsigned_integer_get_value(field, value);
270 goto end;
271
272error:
273 ret = -1;
274end:
275 bt_put(field_type);
276 bt_put(field);
277 return ret;
278}
279
280BT_HIDDEN
281int get_payload_int_field_value(FILE *err, struct bt_ctf_event *event,
282 const char *field_name, int64_t *value)
283{
284 struct bt_ctf_field *field = NULL;
285 struct bt_ctf_field_type *field_type = NULL;
286 int ret;
287
288 field = get_payload_field(err, event, field_name);
289 if (!field) {
290 fprintf(err, "[error] %s in %s:%d\n", __func__,
291 __FILE__, __LINE__);
292 goto error;
293 }
294
295 field_type = bt_ctf_field_get_type(field);
296 if (!field_type) {
297 fprintf(err, "[error] %s in %s:%d\n", __func__,
298 __FILE__, __LINE__);
299 goto error;
300 }
301
1487a16a 302 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
4f45f9bb
JD		 303 fprintf(err, "[error] %s in %s:%d\n", __func__,
304 __FILE__, __LINE__);
305 goto error;
306 }
307
308 if (bt_ctf_field_type_integer_get_signed(field_type) != 1) {
309 fprintf(err, "[error] %s in %s:%d\n", __func__,
310 __FILE__, __LINE__);
311 goto error;
312 }
313
314 ret = bt_ctf_field_signed_integer_get_value(field, value);
315 goto end;
316
317error:
318 ret = -1;
319end:
320 bt_put(field_type);
321 bt_put(field);
322 return ret;
323}
324
325BT_HIDDEN
326int get_payload_string_field_value(FILE *err,
327 struct bt_ctf_event *event, const char *field_name,
328 const char **value)
329{
330 struct bt_ctf_field *field = NULL;
331 struct bt_ctf_field_type *field_type = NULL;
332 int ret;
333
65db8b88
JD		 334 /*
335 * The field might not exist, no error here.
336 */
4f45f9bb
JD		 337 field = get_payload_field(err, event, field_name);
338 if (!field) {
4f45f9bb
JD		 339 goto error;
340 }
341
342 field_type = bt_ctf_field_get_type(field);
343 if (!field_type) {
344 fprintf(err, "[error] %s in %s:%d\n", __func__,
345 __FILE__, __LINE__);
346 goto error;
347 }
348
1487a16a 349 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_STRING) {
4f45f9bb
JD		 350 fprintf(err, "[error] %s in %s:%d\n", __func__,
351 __FILE__, __LINE__);
352 goto error;
353 }
354
355 *value = bt_ctf_field_string_get_value(field);
356 if (!*value) {
357 fprintf(err, "[error] %s in %s:%d\n", __func__,
358 __FILE__, __LINE__);
359 goto error;
360 }
361
362 ret = 0;
363 goto end;
364
365error:
366 ret = -1;
367end:
368 bt_put(field_type);
369 bt_put(field);
370 return ret;
371}
372
373BT_HIDDEN
374int get_payload_build_id_field_value(FILE *err,
375 struct bt_ctf_event *event, const char *field_name,
376 uint8_t **build_id, uint64_t *build_id_len)
377{
378 struct bt_ctf_field *field = NULL, *seq_len = NULL;
379 struct bt_ctf_field_type *field_type = NULL;
380 struct bt_ctf_field *seq_field = NULL;
381 uint64_t i;
382 int ret;
383
384 *build_id = NULL;
385
386 field = get_payload_field(err, event, field_name);
387 if (!field) {
388 fprintf(err, "[error] %s in %s:%d\n", __func__,
389 __FILE__, __LINE__);
390 goto error;
391 }
392
393 field_type = bt_ctf_field_get_type(field);
394 if (!field_type) {
395 fprintf(err, "[error] %s in %s:%d\n", __func__,
396 __FILE__, __LINE__);
397 goto error;
398 }
399
1487a16a 400 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_SEQUENCE) {
4f45f9bb
JD		 401 fprintf(err, "[error] %s in %s:%d\n", __func__,
402 __FILE__, __LINE__);
403 goto error;
404 }
405 BT_PUT(field_type);
406
407 seq_len = bt_ctf_field_sequence_get_length(field);
408 if (!seq_len) {
409 fprintf(err, "[error] %s in %s:%d\n", __func__,
410 __FILE__, __LINE__);
411 goto error;
412 }
413
414 ret = bt_ctf_field_unsigned_integer_get_value(seq_len, build_id_len);
415 if (ret) {
416 fprintf(err, "[error] %s in %s:%d\n", __func__,
417 __FILE__, __LINE__);
418 goto error;
419 }
420 BT_PUT(seq_len);
421
422 *build_id = g_new0(uint8_t, *build_id_len);
423 if (!*build_id) {
424 fprintf(err, "[error] %s in %s:%d\n", __func__,
425 __FILE__, __LINE__);
426 goto error;
427 }
428
429 for (i = 0; i < *build_id_len; i++) {
430 uint64_t tmp;
431
432 seq_field = bt_ctf_field_sequence_get_field(field, i);
433 if (!seq_field) {
434 fprintf(err, "[error] %s in %s:%d\n", __func__,
435 __FILE__, __LINE__);
436 goto error;
437 }
438
439 ret = bt_ctf_field_unsigned_integer_get_value(seq_field, &tmp);
440 if (ret) {
441 fprintf(err, "[error] %s in %s:%d\n", __func__,
442 __FILE__, __LINE__);
443 goto error;
444 }
445 BT_PUT(seq_field);
446 (*build_id)[i] = (uint8_t) tmp;
447 }
448 ret = 0;
449 goto end;
450
451error:
452 g_free(*build_id);
453 ret = -1;
454end:
455 bt_put(field_type);
456 bt_put(field);
457 return ret;
458}
459
460static
461struct debug_info *lookup_trace_debug_info(struct debug_info_iterator *debug_it,
504db471
JD		 462 struct bt_ctf_trace *writer_trace,
463 struct debug_info_trace *di_trace)
4f45f9bb
JD		 464{
465 return (struct debug_info *) g_hash_table_lookup(
504db471 466 di_trace->trace_debug_map,
4f45f9bb
JD		 467 (gpointer) writer_trace);
468}
469
470static
471struct debug_info *insert_new_debug_info(struct debug_info_iterator *debug_it,
504db471
JD		 472 struct bt_ctf_trace *writer_trace,
473 struct debug_info_trace *di_trace)
4f45f9bb
JD		 474{
475 struct debug_info *debug_info = NULL;
476 struct bt_value *field = NULL;
477 const char *str_value;
478 enum bt_value_status ret;
479
480 field = bt_ctf_trace_get_environment_field_value_by_name(writer_trace,
481 "domain");
482 /* No domain field, no debug info */
483 if (!field) {
484 goto end;
485 }
486 ret = bt_value_string_get(field, &str_value);
487 if (ret != BT_VALUE_STATUS_OK) {
488 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
489 __FILE__, __LINE__);
490 goto end;
491 }
492 /* Domain not ust, no debug info */
493 if (strcmp(str_value, "ust") != 0) {
494 goto end;
495 }
496 BT_PUT(field);
497
498 /* No tracer_name, no debug info */
499 field = bt_ctf_trace_get_environment_field_value_by_name(writer_trace,
500 "tracer_name");
501 /* No tracer_name, no debug info */
502 if (!field) {
503 goto end;
504 }
505 ret = bt_value_string_get(field, &str_value);
506 if (ret != BT_VALUE_STATUS_OK) {
507 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
508 __FILE__, __LINE__);
509 goto end;
510 }
511 /* Tracer_name not lttng-ust, no debug info */
512 if (strcmp(str_value, "lttng-ust") != 0) {
513 goto end;
514 }
515 BT_PUT(field);
516
9d325e17 517 debug_info = debug_info_create(debug_it->debug_info_component);
4f45f9bb
JD		 518 if (!debug_info) {
519 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
520 __FILE__, __LINE__);
521 goto end;
522 }
523
504db471 524 g_hash_table_insert(di_trace->trace_debug_map, (gpointer) writer_trace,
4f45f9bb
JD		 525 debug_info);
526
527end:
528 bt_put(field);
529 return debug_info;
530}
531
532static
533struct debug_info *get_trace_debug_info(struct debug_info_iterator *debug_it,
504db471
JD		 534 struct bt_ctf_trace *writer_trace,
535 struct debug_info_trace *di_trace)
4f45f9bb
JD		 536{
537 struct debug_info *debug_info;
538
504db471 539 debug_info = lookup_trace_debug_info(debug_it, writer_trace, di_trace);
4f45f9bb
JD		 540 if (debug_info) {
541 goto end;
542 }
543
504db471 544 debug_info = insert_new_debug_info(debug_it, writer_trace, di_trace);
4f45f9bb
JD		 545
546end:
547 return debug_info;
548}
549
550static
504db471 551struct debug_info_trace *lookup_trace(struct debug_info_iterator *debug_it,
4f45f9bb
JD		 552 struct bt_ctf_trace *trace)
553{
504db471 554 return (struct debug_info_trace *) g_hash_table_lookup(
4f45f9bb
JD		 555 debug_it->trace_map,
556 (gpointer) trace);
557}
558
1c78e839
JD		 559static
560enum debug_info_stream_state *insert_new_stream_state(
561 struct debug_info_iterator *debug_it,
562 struct debug_info_trace *di_trace, struct bt_ctf_stream *stream)
563{
564 enum debug_info_stream_state *v = NULL;
565
566 v = g_new0(enum debug_info_stream_state, 1);
567 if (!v) {
568 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
569 __FILE__, __LINE__);
ec273a88 570 goto end;
1c78e839
JD		 571 }
572 *v = DEBUG_INFO_UNKNOWN_STREAM;
573
574 g_hash_table_insert(di_trace->stream_states, stream, v);
575
ec273a88 576end:
1c78e839
JD		 577 return v;
578}
579
580static
581void check_completed_trace(gpointer key, gpointer value, gpointer user_data)
582{
583 enum debug_info_stream_state *state = value;
584 int *trace_completed = user_data;
585
586 if (*state != DEBUG_INFO_COMPLETED_STREAM) {
587 *trace_completed = 0;
588 }
589}
590
591static
592gboolean empty_ht(gpointer key, gpointer value, gpointer user_data)
593{
594 return TRUE;
595}
596
597BT_HIDDEN
598void debug_info_close_trace(struct debug_info_iterator *debug_it,
599 struct debug_info_trace *di_trace)
600{
ec273a88 601 if (di_trace->static_listener_id >= 0) {
1c78e839
JD		 602 bt_ctf_trace_remove_is_static_listener(di_trace->trace,
603 di_trace->static_listener_id);
604 }
605
606 /* Empty the stream class HT. */
607 g_hash_table_foreach_remove(di_trace->stream_class_map,
608 empty_ht, NULL);
609 g_hash_table_destroy(di_trace->stream_class_map);
610
611 /* Empty the stream HT. */
612 g_hash_table_foreach_remove(di_trace->stream_map,
613 empty_ht, NULL);
614 g_hash_table_destroy(di_trace->stream_map);
615
616 /* Empty the stream state HT. */
617 g_hash_table_foreach_remove(di_trace->stream_states,
618 empty_ht, NULL);
619 g_hash_table_destroy(di_trace->stream_states);
620
621 /* Empty the packet HT. */
622 g_hash_table_foreach_remove(di_trace->packet_map,
623 empty_ht, NULL);
624 g_hash_table_destroy(di_trace->packet_map);
625
626 /* Empty the trace_debug HT. */
627 g_hash_table_foreach_remove(di_trace->trace_debug_map,
628 empty_ht, NULL);
629 g_hash_table_destroy(di_trace->trace_debug_map);
630}
631
cb0a5cf8
JD		 632static
633int sync_event_classes(struct debug_info_iterator *debug_it,
634 struct bt_ctf_stream *stream,
635 struct bt_ctf_stream *writer_stream)
636{
637 int int_ret;
638 struct bt_ctf_stream_class *stream_class = NULL,
639 *writer_stream_class = NULL;
640 enum bt_component_status ret;
641
642 stream_class = bt_ctf_stream_get_class(stream);
643 if (!stream_class) {
644 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
645 __FILE__, __LINE__);
646 goto error;
647 }
648
649 writer_stream_class = bt_ctf_stream_get_class(writer_stream);
650 if (!writer_stream_class) {
651 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
652 __FILE__, __LINE__);
653 goto error;
654 }
655
656 ret = ctf_copy_event_classes(debug_it->err, stream_class,
657 writer_stream_class);
658 if (ret != BT_COMPONENT_STATUS_OK) {
659 goto error;
660 }
661
662 int_ret = 0;
663 goto end;
664
665error:
666 int_ret = -1;
667end:
668 bt_put(stream_class);
669 bt_put(writer_stream_class);
670 return int_ret;
671}
672
1c78e839
JD		 673static
674void trace_is_static_listener(struct bt_ctf_trace *trace, void *data)
675{
676 struct debug_info_trace *di_trace = data;
cb0a5cf8
JD		 677 struct debug_info_iterator *debug_it = di_trace->debug_it;
678 int trace_completed = 1, ret, nr_stream, i;
679 struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
680 struct bt_ctf_trace *writer_trace = di_trace->writer_trace;
681
682 /*
683 * When the trace becomes static, make sure that we have all
684 * the event classes in our stream_class copies before setting it
685 * static as well.
686 */
687 nr_stream = bt_ctf_trace_get_stream_count(trace);
688 for (i = 0; i < nr_stream; i++) {
689 stream = bt_ctf_trace_get_stream_by_index(trace, i);
690 if (!stream) {
691 fprintf(debug_it->err,
692 "[error] %s in %s:%d\n", __func__,
693 __FILE__, __LINE__);
694 goto error;
695 }
696 writer_stream = bt_ctf_trace_get_stream_by_index(writer_trace, i);
697 if (!writer_stream) {
698 fprintf(debug_it->err,
699 "[error] %s in %s:%d\n", __func__,
700 __FILE__, __LINE__);
701 goto error;
702 }
703 ret = sync_event_classes(di_trace->debug_it, stream, writer_stream);
704 if (ret) {
705 fprintf(debug_it->err,
706 "[error] %s in %s:%d\n", __func__,
707 __FILE__, __LINE__);
708 goto error;
709 }
710 BT_PUT(stream);
711 BT_PUT(writer_stream);
712 }
1c78e839 713
cb0a5cf8 714 bt_ctf_trace_set_is_static(di_trace->writer_trace);
1c78e839
JD		 715 di_trace->trace_static = 1;
716
717 g_hash_table_foreach(di_trace->stream_states,
718 check_completed_trace, &trace_completed);
719 if (trace_completed) {
720 debug_info_close_trace(di_trace->debug_it, di_trace);
721 g_hash_table_remove(di_trace->debug_it->trace_map,
722 di_trace->trace);
723 }
cb0a5cf8
JD		 724
725error:
726 bt_put(writer_stream);
727 bt_put(stream);
1c78e839
JD		 728}
729
4f45f9bb 730static
504db471
JD		 731struct debug_info_trace *insert_new_trace(struct debug_info_iterator *debug_it,
732 struct bt_ctf_stream *stream) {
4f45f9bb 733 struct bt_ctf_trace *writer_trace = NULL;
504db471
JD		 734 struct debug_info_trace *di_trace = NULL;
735 struct bt_ctf_trace *trace = NULL;
736 struct bt_ctf_stream_class *stream_class = NULL;
cb0a5cf8 737 struct bt_ctf_stream *writer_stream = NULL;
1c78e839 738 int ret, nr_stream, i;
4f45f9bb
JD		 739
740 writer_trace = bt_ctf_trace_create();
741 if (!writer_trace) {
742 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
743 __FILE__, __LINE__);
744 goto error;
745 }
504db471
JD		 746
747 stream_class = bt_ctf_stream_get_class(stream);
748 if (!stream_class) {
749 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
750 __FILE__, __LINE__);
751 goto error;
752 }
753
754 trace = bt_ctf_stream_class_get_trace(stream_class);
755 if (!trace) {
756 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
757 __FILE__, __LINE__);
758 goto error;
759 }
4f45f9bb
JD		 760
761 ret = ctf_copy_trace(debug_it->err, trace, writer_trace);
762 if (ret != BT_COMPONENT_STATUS_OK) {
763 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
764 __FILE__, __LINE__);
765 goto error;
766 }
767
504db471
JD		 768 di_trace = g_new0(struct debug_info_trace, 1);
769 if (!di_trace) {
770 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
771 __FILE__, __LINE__);
772 goto error;
773 }
774
775 di_trace->trace = trace;
776 di_trace->writer_trace = writer_trace;
777 di_trace->debug_info_component = debug_it->debug_info_component;
1c78e839 778 di_trace->debug_it = debug_it;
504db471
JD		 779 di_trace->stream_map = g_hash_table_new_full(g_direct_hash,
780 g_direct_equal, NULL, (GDestroyNotify) unref_stream);
781 di_trace->stream_class_map = g_hash_table_new_full(g_direct_hash,
782 g_direct_equal, NULL, (GDestroyNotify) unref_stream_class);
783 di_trace->packet_map = g_hash_table_new_full(g_direct_hash,
784 g_direct_equal, NULL, (GDestroyNotify) unref_packet);
785 di_trace->trace_debug_map = g_hash_table_new_full(g_direct_hash,
786 g_direct_equal, NULL, (GDestroyNotify) unref_debug_info);
1c78e839
JD		 787 di_trace->stream_states = g_hash_table_new_full(g_direct_hash,
788 g_direct_equal, NULL, destroy_stream_state_key);
cb0a5cf8 789 g_hash_table_insert(debug_it->trace_map, (gpointer) trace, di_trace);
1c78e839
JD		 790
791 /* Set all the existing streams in the unknown state. */
792 nr_stream = bt_ctf_trace_get_stream_count(trace);
793 for (i = 0; i < nr_stream; i++) {
794 stream = bt_ctf_trace_get_stream_by_index(trace, i);
795 if (!stream) {
796 fprintf(debug_it->err,
797 "[error] %s in %s:%d\n", __func__,
798 __FILE__, __LINE__);
799 goto error;
800 }
801 insert_new_stream_state(debug_it, di_trace, stream);
cb0a5cf8
JD		 802 writer_stream = insert_new_stream(debug_it, stream, di_trace);
803 if (!writer_stream) {
804 fprintf(debug_it->err,
805 "[error] %s in %s:%d\n", __func__,
806 __FILE__, __LINE__);
807 goto error;
808 }
809 bt_get(writer_stream);
810 ret = sync_event_classes(debug_it, stream, writer_stream);
811 if (ret) {
812 fprintf(debug_it->err,
813 "[error] %s in %s:%d\n", __func__,
814 __FILE__, __LINE__);
815 goto error;
816 }
817 BT_PUT(writer_stream);
1c78e839
JD		 818 BT_PUT(stream);
819 }
820
821 /* Check if the trace is already static or register a listener. */
822 if (bt_ctf_trace_is_static(trace)) {
823 di_trace->trace_static = 1;
824 di_trace->static_listener_id = -1;
cb0a5cf8 825 bt_ctf_trace_set_is_static(writer_trace);
1c78e839
JD		 826 } else {
827 ret = bt_ctf_trace_add_is_static_listener(trace,
828 trace_is_static_listener, di_trace);
829 if (ret < 0) {
830 fprintf(debug_it->err,
831 "[error] %s in %s:%d\n", __func__, __FILE__,
832 __LINE__);
833 goto error;
834 }
835 di_trace->static_listener_id = ret;
836 }
504db471 837
504db471 838
4f45f9bb
JD		 839 goto end;
840
841error:
842 BT_PUT(writer_trace);
504db471
JD		 843 g_free(di_trace);
844 di_trace = NULL;
4f45f9bb 845end:
cb0a5cf8
JD		 846 bt_put(stream);
847 bt_put(writer_stream);
504db471
JD		 848 bt_put(stream_class);
849 bt_put(trace);
850 return di_trace;
4f45f9bb
JD		 851}
852
853static
854struct bt_ctf_packet *lookup_packet(struct debug_info_iterator *debug_it,
504db471
JD		 855 struct bt_ctf_packet *packet,
856 struct debug_info_trace *di_trace)
4f45f9bb
JD		 857{
858 return (struct bt_ctf_packet *) g_hash_table_lookup(
504db471 859 di_trace->packet_map,
4f45f9bb
JD		 860 (gpointer) packet);
861}
862
863static
864struct bt_ctf_packet *insert_new_packet(struct debug_info_iterator *debug_it,
865 struct bt_ctf_packet *packet,
504db471
JD		 866 struct bt_ctf_stream *writer_stream,
867 struct debug_info_trace *di_trace)
4f45f9bb
JD		 868{
869 struct bt_ctf_packet *writer_packet;
387483fc 870 int ret;
4f45f9bb
JD		 871
872 writer_packet = bt_ctf_packet_create(writer_stream);
873 if (!writer_packet) {
874 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
875 __FILE__, __LINE__);
387483fc
JD		 876 goto error;
877 }
878
879 ret = ctf_packet_copy_header(debug_it->err, packet, writer_packet);
880 if (ret) {
881 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
882 __FILE__, __LINE__);
883 goto error;
4f45f9bb 884 }
4f45f9bb 885
387483fc
JD		 886 g_hash_table_insert(di_trace->packet_map, (gpointer) packet,
887 writer_packet);
888 goto end;
889
890error:
891 BT_PUT(writer_packet);
4f45f9bb
JD		 892end:
893 return writer_packet;
894}
895
896static
897int add_debug_info_fields(FILE *err,
898 struct bt_ctf_field_type *writer_event_context_type,
899 struct debug_info_component *component)
900{
901 struct bt_ctf_field_type *ip_field = NULL, *debug_field_type = NULL,
902 *bin_field_type = NULL, *func_field_type = NULL,
903 *src_field_type = NULL;
904 int ret = 0;
905
906 ip_field = bt_ctf_field_type_structure_get_field_type_by_name(
907 writer_event_context_type, "_ip");
908 /* No ip field, so no debug info. */
909 if (!ip_field) {
910 goto end;
911 }
912 BT_PUT(ip_field);
913
914 debug_field_type = bt_ctf_field_type_structure_get_field_type_by_name(
915 writer_event_context_type,
916 component->arg_debug_info_field_name);
917 /* Already existing debug_info field, no need to add it. */
918 if (debug_field_type) {
919 goto end;
920 }
921
922 debug_field_type = bt_ctf_field_type_structure_create();
923 if (!debug_field_type) {
924 fprintf(err, "[error] %s in %s:%d\n", __func__,
925 __FILE__, __LINE__);
926 goto error;
927 }
928
929 bin_field_type = bt_ctf_field_type_string_create();
930 if (!bin_field_type) {
931 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
932 __LINE__);
933 goto error;
934 }
935
936 func_field_type = bt_ctf_field_type_string_create();
937 if (!func_field_type) {
938 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
939 __LINE__);
940 goto error;
941 }
942
943 src_field_type = bt_ctf_field_type_string_create();
944 if (!src_field_type) {
945 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
946 __LINE__);
947 goto error;
948 }
949
950 ret = bt_ctf_field_type_structure_add_field(debug_field_type,
951 bin_field_type, "bin");
952 if (ret) {
953 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
954 __LINE__);
955 goto error;
956 }
957
958 ret = bt_ctf_field_type_structure_add_field(debug_field_type,
959 func_field_type, "func");
960 if (ret) {
961 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
962 __LINE__);
963 goto error;
964 }
965
966 ret = bt_ctf_field_type_structure_add_field(debug_field_type,
967 src_field_type, "src");
968 if (ret) {
969 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
970 __LINE__);
971 goto error;
972 }
973
974 ret = bt_ctf_field_type_structure_add_field(writer_event_context_type,
975 debug_field_type, component->arg_debug_info_field_name);
976 if (ret) {
977 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
978 __LINE__);
979 goto error;
980 }
981
982 ret = 0;
983 goto end;
984
985error:
986 BT_PUT(debug_field_type);
987 ret = -1;
988end:
989 bt_put(src_field_type);
990 bt_put(func_field_type);
991 bt_put(bin_field_type);
992 bt_put(debug_field_type);
993 return ret;
994}
995
996static
997int create_debug_info_event_context_type(FILE *err,
998 struct bt_ctf_field_type *event_context_type,
999 struct bt_ctf_field_type *writer_event_context_type,
1000 struct debug_info_component *component)
1001{
1002 int ret, nr_fields, i;
1003
1004 nr_fields = bt_ctf_field_type_structure_get_field_count(event_context_type);
1005 for (i = 0; i < nr_fields; i++) {
1006 struct bt_ctf_field_type *field_type = NULL;
1007 const char *field_name;
1008
1009 if (bt_ctf_field_type_structure_get_field(event_context_type,
1010 &field_name, &field_type, i) < 0) {
1011 fprintf(err, "[error] %s in %s:%d\n", __func__,
1012 __FILE__, __LINE__);
1013 goto error;
1014 }
1015
1016 ret = bt_ctf_field_type_structure_add_field(writer_event_context_type,
1017 field_type, field_name);
1018 BT_PUT(field_type);
1019 if (ret) {
1020 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1021 __LINE__);
1022 goto error;
1023 }
1024 }
1025
1026 ret = add_debug_info_fields(err, writer_event_context_type,
1027 component);
1028 goto end;
1029
1030error:
1031 ret = -1;
1032end:
1033 return ret;
1034}
1035
1036static
1037struct bt_ctf_stream_class *copy_stream_class_debug_info(FILE *err,
1038 struct bt_ctf_stream_class *stream_class,
1039 struct bt_ctf_trace *writer_trace,
1040 struct debug_info_component *component)
1041{
1042 struct bt_ctf_field_type *type = NULL;
1043 struct bt_ctf_stream_class *writer_stream_class = NULL;
1044 struct bt_ctf_field_type *writer_event_context_type = NULL;
1045 int ret_int;
1046 const char *name = bt_ctf_stream_class_get_name(stream_class);
1047
2d64a1eb 1048 writer_stream_class = bt_ctf_stream_class_create_empty(name);
4f45f9bb
JD		 1049 if (!writer_stream_class) {
1050 fprintf(err, "[error] %s in %s:%d\n",
1051 __func__, __FILE__, __LINE__);
1052 goto error;
1053 }
1054
1055 type = bt_ctf_stream_class_get_packet_context_type(stream_class);
2d64a1eb
JD		 1056 if (type) {
1057 ret_int = bt_ctf_stream_class_set_packet_context_type(
1058 writer_stream_class, type);
1059 if (ret_int < 0) {
1060 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1061 __LINE__);
1062 goto error;
1063 }
1064 BT_PUT(type);
4f45f9bb 1065 }
4f45f9bb
JD		 1066
1067 type = bt_ctf_stream_class_get_event_header_type(stream_class);
290b95cc
MD		 1068 if (type) {
1069 ret_int = bt_ctf_stream_class_set_event_header_type(
1070 writer_stream_class, type);
1071 if (ret_int < 0) {
1072 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1073 __LINE__);
1074 goto error;
1075 }
1076 BT_PUT(type);
4f45f9bb 1077 }
4f45f9bb
JD		 1078
1079 type = bt_ctf_stream_class_get_event_context_type(stream_class);
1080 if (type) {
1081 writer_event_context_type = bt_ctf_field_type_structure_create();
1082 if (!writer_event_context_type) {
1083 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1084 __LINE__);
1085 goto error;
1086 }
1087 ret_int = create_debug_info_event_context_type(err, type,
1088 writer_event_context_type, component);
1089 if (ret_int) {
1090 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1091 __LINE__);
1092 goto error;
1093 }
1094 BT_PUT(type);
1095
1096 ret_int = bt_ctf_stream_class_set_event_context_type(
1097 writer_stream_class, writer_event_context_type);
1098 if (ret_int < 0) {
1099 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1100 __LINE__);
1101 goto error;
1102 }
1103 BT_PUT(writer_event_context_type);
1104 }
1105
1106 goto end;
1107
1108error:
1109 BT_PUT(writer_stream_class);
1110end:
1111 bt_put(writer_event_context_type);
1112 bt_put(type);
1113 return writer_stream_class;
1114}
1115
1116/*
1117 * Add the original clock classes to the new trace, we do not need to copy
1118 * them, and if we did, we would have to manually inspect the stream class
1119 * to update the integers mapping to a clock.
1120 */
1121static
1122int add_clock_classes(FILE *err, struct bt_ctf_trace *writer_trace,
1123 struct bt_ctf_stream_class *writer_stream_class,
1124 struct bt_ctf_trace *trace)
1125{
1126 int ret, clock_class_count, i;
1127
1128 clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
1129
1130 for (i = 0; i < clock_class_count; i++) {
1131 struct bt_ctf_clock_class *clock_class =
9ac68eb1 1132 bt_ctf_trace_get_clock_class_by_index(trace, i);
30480ffe 1133 struct bt_ctf_clock_class *existing_clock_class = NULL;
4f45f9bb
JD		 1134
1135 if (!clock_class) {
1136 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1137 __LINE__);
1138 goto error;
1139 }
1140
30480ffe
PP		 1141 existing_clock_class = bt_ctf_trace_get_clock_class_by_name(
1142 writer_trace, bt_ctf_clock_class_get_name(clock_class));
1143 bt_put(existing_clock_class);
1144 if (existing_clock_class) {
1145 bt_put(clock_class);
1146 continue;
1147 }
1148
4f45f9bb
JD		 1149 ret = bt_ctf_trace_add_clock_class(writer_trace, clock_class);
1150 BT_PUT(clock_class);
1151 if (ret != 0) {
1152 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1153 __LINE__);
1154 goto error;
1155 }
1156 }
1157
1158 ret = 0;
1159 goto end;
1160
1161error:
1162 ret = -1;
1163end:
1164 return ret;
1165
1166}
1167
1168static
1169struct bt_ctf_stream_class *insert_new_stream_class(
1170 struct debug_info_iterator *debug_it,
1171 struct bt_ctf_stream_class *stream_class)
1172{
1173 struct bt_ctf_stream_class *writer_stream_class = NULL;
1174 struct bt_ctf_trace *trace, *writer_trace = NULL;
504db471 1175 struct debug_info_trace *di_trace;
4f45f9bb
JD		 1176 enum bt_component_status ret;
1177 int int_ret;
1178
1179 trace = bt_ctf_stream_class_get_trace(stream_class);
1180 if (!trace) {
1181 fprintf(debug_it->err,
1182 "[error] %s in %s:%d\n", __func__, __FILE__,
1183 __LINE__);
1184 goto error;
1185 }
1186
504db471
JD		 1187 di_trace = lookup_trace(debug_it, trace);
1188 if (!di_trace) {
1189 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1190 __FILE__, __LINE__);
1191 ret = BT_COMPONENT_STATUS_ERROR;
1192 goto error;
4f45f9bb 1193 }
504db471 1194 writer_trace = di_trace->writer_trace;
4f45f9bb
JD		 1195 bt_get(writer_trace);
1196
1197 writer_stream_class = copy_stream_class_debug_info(debug_it->err, stream_class,
1198 writer_trace, debug_it->debug_info_component);
1199 if (!writer_stream_class) {
1200 fprintf(debug_it->err, "[error] Failed to copy stream class\n");
1201 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1202 __func__, __FILE__, __LINE__);
1203 goto error;
1204 }
1205
1206 int_ret = bt_ctf_trace_add_stream_class(writer_trace, writer_stream_class);
1207 if (int_ret) {
1208 fprintf(debug_it->err,
1209 "[error] %s in %s:%d\n", __func__, __FILE__,
1210 __LINE__);
1211 goto error;
1212 }
1213
1214 ret = add_clock_classes(debug_it->err, writer_trace,
1215 writer_stream_class, trace);
1216 if (ret != BT_COMPONENT_STATUS_OK) {
1217 fprintf(debug_it->err,
1218 "[error] %s in %s:%d\n", __func__, __FILE__,
1219 __LINE__);
1220 goto error;
1221 }
4f45f9bb 1222
504db471 1223 g_hash_table_insert(di_trace->stream_class_map,
4f45f9bb
JD		 1224 (gpointer) stream_class, writer_stream_class);
1225
1226 goto end;
1227
1228error:
1229 BT_PUT(writer_stream_class);
1230end:
1231 bt_put(trace);
1232 bt_put(writer_trace);
1233 return writer_stream_class;
1234}
1235
1236static
1237struct bt_ctf_stream *insert_new_stream(
1238 struct debug_info_iterator *debug_it,
504db471
JD		 1239 struct bt_ctf_stream *stream,
1240 struct debug_info_trace *di_trace)
4f45f9bb
JD		 1241{
1242 struct bt_ctf_stream *writer_stream = NULL;
504db471 1243 struct bt_ctf_stream_class *stream_class = NULL;
4f45f9bb
JD		 1244 struct bt_ctf_stream_class *writer_stream_class = NULL;
1245
504db471
JD		 1246 stream_class = bt_ctf_stream_get_class(stream);
1247 if (!stream_class) {
1248 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1249 __func__, __FILE__, __LINE__);
1250 goto error;
1251 }
1252
4f45f9bb 1253 writer_stream_class = g_hash_table_lookup(
504db471 1254 di_trace->stream_class_map,
4f45f9bb
JD		 1255 (gpointer) stream_class);
1256
1257 if (!writer_stream_class) {
1258 writer_stream_class = insert_new_stream_class(debug_it,
1259 stream_class);
1260 if (!writer_stream_class) {
1261 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1262 __func__, __FILE__, __LINE__);
1263 goto error;
1264 }
1265 }
1266 bt_get(writer_stream_class);
1267
1268 writer_stream = bt_ctf_stream_create(writer_stream_class,
1269 bt_ctf_stream_get_name(stream));
1270 if (!writer_stream) {
1271 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1272 __func__, __FILE__, __LINE__);
1273 goto error;
1274 }
1275
504db471 1276 g_hash_table_insert(di_trace->stream_map, (gpointer) stream,
4f45f9bb
JD		 1277 writer_stream);
1278
1279 goto end;
1280
1281error:
1282 BT_PUT(writer_stream);
1283end:
504db471 1284 bt_put(stream_class);
4f45f9bb
JD		 1285 bt_put(writer_stream_class);
1286 return writer_stream;
1287}
1288
1289static
1290struct bt_ctf_stream *lookup_stream(struct debug_info_iterator *debug_it,
504db471
JD		 1291 struct bt_ctf_stream *stream,
1292 struct debug_info_trace *di_trace)
4f45f9bb
JD		 1293{
1294 return (struct bt_ctf_stream *) g_hash_table_lookup(
504db471 1295 di_trace->stream_map, (gpointer) stream);
4f45f9bb
JD		 1296}
1297
1298static
1299struct bt_ctf_event_class *get_event_class(struct debug_info_iterator *debug_it,
1300 struct bt_ctf_stream_class *writer_stream_class,
1301 struct bt_ctf_event_class *event_class)
1302{
a9f0d01b
PP		 1303 return bt_ctf_stream_class_get_event_class_by_id(writer_stream_class,
1304 bt_ctf_event_class_get_id(event_class));
4f45f9bb
JD		 1305}
1306
504db471
JD		 1307static
1308struct debug_info_trace *lookup_di_trace_from_stream(
1309 struct debug_info_iterator *debug_it,
1310 struct bt_ctf_stream *stream)
1311{
1312 struct bt_ctf_stream_class *stream_class = NULL;
1313 struct bt_ctf_trace *trace = NULL;
1314 struct debug_info_trace *di_trace = NULL;
1315
1316 stream_class = bt_ctf_stream_get_class(stream);
1317 if (!stream_class) {
1318 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1319 __func__, __FILE__, __LINE__);
1320 goto end;
1321 }
1322
1323 trace = bt_ctf_stream_class_get_trace(stream_class);
1324 if (!trace) {
1325 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1326 __func__, __FILE__, __LINE__);
1327 goto end;
1328 }
1329
1330 di_trace = (struct debug_info_trace *) g_hash_table_lookup(
1331 debug_it->trace_map, (gpointer) trace);
1332
1333end:
1334 BT_PUT(stream_class);
1335 BT_PUT(trace);
1336 return di_trace;
1337}
1338
4f45f9bb
JD		 1339static
1340struct bt_ctf_stream *get_writer_stream(
1341 struct debug_info_iterator *debug_it,
1342 struct bt_ctf_packet *packet, struct bt_ctf_stream *stream)
1343{
1344 struct bt_ctf_stream_class *stream_class = NULL;
1345 struct bt_ctf_stream *writer_stream = NULL;
504db471 1346 struct debug_info_trace *di_trace = NULL;
4f45f9bb
JD		 1347
1348 stream_class = bt_ctf_stream_get_class(stream);
1349 if (!stream_class) {
1350 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1351 __func__, __FILE__, __LINE__);
1352 goto error;
1353 }
1354
504db471
JD		 1355 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1356 if (!di_trace) {
1357 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1358 __func__, __FILE__, __LINE__);
1359 goto error;
1360 }
1361
1362 writer_stream = lookup_stream(debug_it, stream, di_trace);
4f45f9bb 1363 if (!writer_stream) {
504db471
JD		 1364 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1365 __func__, __FILE__, __LINE__);
1366 goto error;
4f45f9bb
JD		 1367 }
1368 bt_get(writer_stream);
1369
1370 goto end;
1371
1372error:
1373 BT_PUT(writer_stream);
1374end:
1375 bt_put(stream_class);
1376 return writer_stream;
1377}
1378
1379BT_HIDDEN
1380struct bt_ctf_packet *debug_info_new_packet(
1381 struct debug_info_iterator *debug_it,
1382 struct bt_ctf_packet *packet)
1383{
1384 struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
4f45f9bb 1385 struct bt_ctf_packet *writer_packet = NULL;
2d64a1eb 1386 struct bt_ctf_field *packet_context = NULL;
504db471 1387 struct debug_info_trace *di_trace;
4f45f9bb
JD		 1388 int int_ret;
1389
1390 stream = bt_ctf_packet_get_stream(packet);
1391 if (!stream) {
1392 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1393 __func__, __FILE__, __LINE__);
1394 goto error;
1395 }
1396
1397 writer_stream = get_writer_stream(debug_it, packet, stream);
1398 if (!writer_stream) {
1399 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1400 __func__, __FILE__, __LINE__);
1401 goto error;
1402 }
1403
504db471
JD		 1404 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1405 if (!di_trace) {
1406 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1407 __FILE__, __LINE__);
1408 goto error;
1409 }
1410
4f45f9bb
JD		 1411 /*
1412 * If a packet was already opened, close it and remove it from
1413 * the HT.
1414 */
504db471 1415 writer_packet = lookup_packet(debug_it, packet, di_trace);
4f45f9bb 1416 if (writer_packet) {
504db471 1417 g_hash_table_remove(di_trace->packet_map, packet);
4f45f9bb
JD		 1418 BT_PUT(writer_packet);
1419 }
1420
504db471
JD		 1421 writer_packet = insert_new_packet(debug_it, packet, writer_stream,
1422 di_trace);
4f45f9bb
JD		 1423 if (!writer_packet) {
1424 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1425 __func__, __FILE__, __LINE__);
1426 goto error;
1427 }
4f45f9bb 1428
2d64a1eb
JD		 1429 packet_context = bt_ctf_packet_get_context(packet);
1430 if (packet_context) {
9877e1aa
JD		 1431 int_ret = ctf_packet_copy_context(debug_it->err,
1432 packet, writer_stream, writer_packet);
1433 if (int_ret < 0) {
2d64a1eb
JD		 1434 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1435 __func__, __FILE__, __LINE__);
1436 goto error;
1437 }
1438 BT_PUT(packet_context);
4f45f9bb
JD		 1439 }
1440
1c78e839 1441 bt_get(writer_packet);
4f45f9bb
JD		 1442 goto end;
1443
1444error:
1445
1446end:
2d64a1eb 1447 bt_put(packet_context);
4f45f9bb
JD		 1448 bt_put(writer_stream);
1449 bt_put(stream);
1450 return writer_packet;
1451}
1452
1453BT_HIDDEN
1454struct bt_ctf_packet *debug_info_close_packet(
1455 struct debug_info_iterator *debug_it,
1456 struct bt_ctf_packet *packet)
1457{
1458 struct bt_ctf_packet *writer_packet = NULL;
504db471
JD		 1459 struct bt_ctf_stream *stream = NULL;
1460 struct debug_info_trace *di_trace;
1461
1462 stream = bt_ctf_packet_get_stream(packet);
1463 if (!stream) {
1464 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1465 __FILE__, __LINE__);
1466 goto end;
1467 }
1468
1469 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1470 if (!di_trace) {
1471 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1472 __FILE__, __LINE__);
1473 goto end;
1474 }
4f45f9bb 1475
504db471 1476 writer_packet = lookup_packet(debug_it, packet, di_trace);
4f45f9bb
JD		 1477 if (!writer_packet) {
1478 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1479 __func__, __FILE__, __LINE__);
1480 goto end;
1481 }
1c78e839 1482 bt_get(writer_packet);
504db471 1483 g_hash_table_remove(di_trace->packet_map, packet);
4f45f9bb
JD		 1484
1485end:
504db471 1486 bt_put(stream);
4f45f9bb
JD		 1487 return writer_packet;
1488}
1489
504db471
JD		 1490BT_HIDDEN
1491struct bt_ctf_stream *debug_info_stream_begin(
1492 struct debug_info_iterator *debug_it,
1493 struct bt_ctf_stream *stream)
1494{
cb0a5cf8 1495 struct bt_ctf_stream *writer_stream = NULL;
1c78e839 1496 enum debug_info_stream_state *state;
504db471
JD		 1497 struct debug_info_trace *di_trace = NULL;
1498
1499 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1500 if (!di_trace) {
1501 di_trace = insert_new_trace(debug_it, stream);
1502 if (!di_trace) {
1503 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1504 __func__, __FILE__, __LINE__);
1c78e839 1505 goto error;
504db471
JD		 1506 }
1507 }
1508
1c78e839
JD		 1509 /* Set the stream as active */
1510 state = g_hash_table_lookup(di_trace->stream_states, stream);
1511 if (!state) {
1512 if (di_trace->trace_static) {
1513 fprintf(debug_it->err, "[error] Adding a new stream "
1514 "on a static trace\n");
1515 goto error;
1516 }
1517 state = insert_new_stream_state(debug_it, di_trace,
1518 stream);
ec273a88
JD		 1519 if (!state) {
1520 fprintf(debug_it->err, "[error] Adding a new stream "
1521 "on a static trace\n");
1522 goto error;
1523 }
1c78e839
JD		 1524 }
1525 if (*state != DEBUG_INFO_UNKNOWN_STREAM) {
1526 fprintf(debug_it->err, "[error] Unexpected stream state %d\n",
1527 *state);
1528 goto error;
1529 }
1530 *state = DEBUG_INFO_ACTIVE_STREAM;
1531
cb0a5cf8
JD		 1532 writer_stream = lookup_stream(debug_it, stream, di_trace);
1533 if (!writer_stream) {
1534 writer_stream = insert_new_stream(debug_it, stream, di_trace);
1535 }
1c78e839 1536 bt_get(writer_stream);
504db471 1537
1c78e839
JD		 1538 goto end;
1539
1540error:
1541 BT_PUT(writer_stream);
504db471
JD		 1542end:
1543 return writer_stream;
1544}
1545
4f45f9bb
JD		 1546BT_HIDDEN
1547struct bt_ctf_stream *debug_info_stream_end(struct debug_info_iterator *debug_it,
1548 struct bt_ctf_stream *stream)
1549{
0bb3da02 1550 struct bt_ctf_stream *writer_stream = NULL;
504db471 1551 struct debug_info_trace *di_trace = NULL;
1c78e839 1552 enum debug_info_stream_state *state;
504db471
JD		 1553
1554 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1555 if (!di_trace) {
1556 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1557 __func__, __FILE__, __LINE__);
1c78e839 1558 goto error;
504db471 1559 }
4f45f9bb 1560
504db471 1561 writer_stream = lookup_stream(debug_it, stream, di_trace);
4f45f9bb
JD		 1562 if (!writer_stream) {
1563 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1564 __func__, __FILE__, __LINE__);
1c78e839 1565 goto error;
4f45f9bb 1566 }
1c78e839
JD		 1567 /*
1568 * Take the ref on the stream and keep it until the notification
1569 * is created.
1570 */
34101229 1571 bt_get(writer_stream);
1c78e839
JD		 1572
1573 state = g_hash_table_lookup(di_trace->stream_states, stream);
1574 if (*state != DEBUG_INFO_ACTIVE_STREAM) {
1575 fprintf(debug_it->err, "[error] Unexpected stream "
1576 "state %d\n", *state);
1577 goto error;
1578 }
1579 *state = DEBUG_INFO_COMPLETED_STREAM;
1580
504db471 1581 g_hash_table_remove(di_trace->stream_map, stream);
4f45f9bb 1582
1c78e839
JD		 1583 if (di_trace->trace_static) {
1584 int trace_completed = 1;
1585
1586 g_hash_table_foreach(di_trace->stream_states,
1587 check_completed_trace, &trace_completed);
1588 if (trace_completed) {
1589 debug_info_close_trace(debug_it, di_trace);
1590 g_hash_table_remove(debug_it->trace_map,
1591 di_trace->trace);
1592 }
1593 }
1594
1595 goto end;
1596
1597error:
1598 BT_PUT(writer_stream);
1599
4f45f9bb
JD		 1600end:
1601 return writer_stream;
1602}
1603
1604static
1605struct debug_info_source *lookup_debug_info(FILE *err,
1606 struct bt_ctf_event *event,
1607 struct debug_info *debug_info)
1608{
1609 int64_t vpid;
1610 uint64_t ip;
1611 struct debug_info_source *dbg_info_src = NULL;
1612 int ret;
1613
1614 ret = get_stream_event_context_int_field_value(err, event,
1615 "_vpid", &vpid);
1616 if (ret) {
1617 goto end;
1618 }
1619
1620 ret = get_stream_event_context_unsigned_int_field_value(err, event,
1621 "_ip", &ip);
1622 if (ret) {
1623 goto end;
1624 }
1625
1626 /* Get debug info for this context. */
1627 dbg_info_src = debug_info_query(debug_info, vpid, ip);
1628
1629end:
1630 return dbg_info_src;
1631}
1632
1633static
1634int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field,
1635 struct debug_info_source *dbg_info_src,
1636 struct debug_info_component *component)
1637{
2afcfbfb 1638 int i, nr_fields, ret = 0;
4f45f9bb
JD		 1639 struct bt_ctf_field_type *debug_field_type = NULL;
1640 struct bt_ctf_field *field = NULL;
1641 struct bt_ctf_field_type *field_type = NULL;
1642
1643 debug_field_type = bt_ctf_field_get_type(debug_field);
1644 if (!debug_field_type) {
1645 fprintf(err, "[error] %s in %s:%d\n", __func__,
1646 __FILE__, __LINE__);
1647 goto error;
1648 }
1649
1650 nr_fields = bt_ctf_field_type_structure_get_field_count(debug_field_type);
1651 for (i = 0; i < nr_fields; i++) {
1652 const char *field_name;
1653
1654 if (bt_ctf_field_type_structure_get_field(debug_field_type,
1655 &field_name, &field_type, i) < 0) {
1656 fprintf(err, "[error] %s in %s:%d\n", __func__,
1657 __FILE__, __LINE__);
1658 goto error;
1659 }
1660 BT_PUT(field_type);
1661
1662 field = bt_ctf_field_structure_get_field_by_index(debug_field, i);
1663 if (!strcmp(field_name, "bin")) {
1664 if (dbg_info_src && dbg_info_src->bin_path) {
1665 GString *tmp = g_string_new(NULL);
1666
1667 if (component->arg_full_path) {
1668 g_string_printf(tmp, "%s%s",
1669 dbg_info_src->bin_path,
1670 dbg_info_src->bin_loc);
1671 } else {
1672 g_string_printf(tmp, "%s%s",
1673 dbg_info_src->short_bin_path,
1674 dbg_info_src->bin_loc);
1675 }
1676 ret = bt_ctf_field_string_set_value(field, tmp->str);
1677 g_string_free(tmp, true);
1678 } else {
1679 ret = bt_ctf_field_string_set_value(field, "");
1680 }
1681 } else if (!strcmp(field_name, "func")) {
1682 if (dbg_info_src && dbg_info_src->func) {
1683 ret = bt_ctf_field_string_set_value(field,
1684 dbg_info_src->func);
1685 } else {
1686 ret = bt_ctf_field_string_set_value(field, "");
1687 }
1688 } else if (!strcmp(field_name, "src")) {
1689 if (dbg_info_src && dbg_info_src->src_path) {
1690 GString *tmp = g_string_new(NULL);
1691
1692 if (component->arg_full_path) {
1693 g_string_printf(tmp, "%s:%" PRId64,
1694 dbg_info_src->src_path,
1695 dbg_info_src->line_no);
1696 } else {
1697 g_string_printf(tmp, "%s:%" PRId64,
1698 dbg_info_src->short_src_path,
1699 dbg_info_src->line_no);
1700 }
1701 ret = bt_ctf_field_string_set_value(field, tmp->str);
1702 g_string_free(tmp, true);
1703 } else {
1704 ret = bt_ctf_field_string_set_value(field, "");
1705 }
1706 }
1707 BT_PUT(field);
1708 if (ret) {
1709 fprintf(err, "[error] %s in %s:%d\n", __func__,
1710 __FILE__, __LINE__);
1711 goto error;
1712 }
1713 }
1714 ret = 0;
1715 goto end;
1716
1717error:
1718 ret = -1;
1719end:
1720 bt_put(field_type);
1721 bt_put(field);
1722 bt_put(debug_field_type);
1723 return ret;
1724}
1725
1726static
1727int copy_set_debug_info_stream_event_context(FILE *err,
1728 struct bt_ctf_field *event_context,
1729 struct bt_ctf_event *event,
1730 struct bt_ctf_event *writer_event,
1731 struct debug_info *debug_info,
1732 struct debug_info_component *component)
1733{
08b6e8e8
JD		 1734 struct bt_ctf_field_type *writer_event_context_type = NULL,
1735 *event_context_type = NULL;
4f45f9bb
JD		 1736 struct bt_ctf_field *writer_event_context = NULL;
1737 struct bt_ctf_field *field = NULL, *copy_field = NULL, *debug_field = NULL;
1738 struct bt_ctf_field_type *field_type = NULL;
1739 struct debug_info_source *dbg_info_src;
1740 int ret, nr_fields, i;
1741
1742 writer_event_context = bt_ctf_event_get_stream_event_context(writer_event);
1743 if (!writer_event_context) {
1744 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
1745 goto error;
1746 }
1747
1748 writer_event_context_type = bt_ctf_field_get_type(writer_event_context);
1749 if (!writer_event_context_type) {
1750 fprintf(err, "[error] %s in %s:%d\n", __func__,
1751 __FILE__, __LINE__);
1752 goto error;
1753 }
1754
08b6e8e8
JD		 1755 event_context_type = bt_ctf_field_get_type(event_context);
1756 if (!event_context_type) {
1757 fprintf(err, "[error] %s in %s:%d\n", __func__,
1758 __FILE__, __LINE__);
1759 goto error;
1760 }
1761
4f45f9bb
JD		 1762 /*
1763 * If it is not a structure, we did not modify it to add the debug info
1764 * fields, so just assign it as is.
1765 */
1487a16a 1766 if (bt_ctf_field_type_get_type_id(writer_event_context_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
4f45f9bb
JD		 1767 ret = bt_ctf_event_set_event_context(writer_event, event_context);
1768 goto end;
1769 }
1770
1771 dbg_info_src = lookup_debug_info(err, event, debug_info);
1772
1773 nr_fields = bt_ctf_field_type_structure_get_field_count(writer_event_context_type);
1774 for (i = 0; i < nr_fields; i++) {
1775 const char *field_name;
1776
1777 if (bt_ctf_field_type_structure_get_field(writer_event_context_type,
1778 &field_name, &field_type, i) < 0) {
1779 fprintf(err, "[error] %s in %s:%d\n", __func__,
1780 __FILE__, __LINE__);
1781 goto error;
1782 }
1783
08b6e8e8
JD		 1784 /*
1785 * Prevent illegal access in the event_context.
1786 */
1787 if (i < bt_ctf_field_type_structure_get_field_count(event_context_type)) {
1788 field = bt_ctf_field_structure_get_field_by_index(event_context, i);
1789 }
4f45f9bb
JD		 1790 /*
1791 * The debug_info field, only exists in the writer event or
1792 * if it was set by a earlier pass of the debug_info plugin.
4f45f9bb
JD		 1793 */
1794 if (!strcmp(field_name, component->arg_debug_info_field_name) &&
1795 !field) {
1796 debug_field = bt_ctf_field_structure_get_field_by_index(
1797 writer_event_context, i);
1798 if (!debug_field) {
1799 fprintf(err, "[error] %s in %s:%d\n", __func__,
1800 __FILE__, __LINE__);
1801 goto error;
1802 }
1803 ret = set_debug_info_field(err, debug_field,
1804 dbg_info_src, component);
1805 if (ret) {
1806 fprintf(err, "[error] %s in %s:%d\n", __func__,
1807 __FILE__, __LINE__);
1808 goto error;
1809 }
1810 BT_PUT(debug_field);
1811 } else {
1812 copy_field = bt_ctf_field_copy(field);
1813 if (!copy_field) {
1814 fprintf(err, "[error] %s in %s:%d\n", __func__,
1815 __FILE__, __LINE__);
1816 goto error;
1817 }
1818
2225de6b
PP		 1819 ret = bt_ctf_field_structure_set_field_by_name(
1820 writer_event_context,
4f45f9bb
JD		 1821 field_name, copy_field);
1822 if (ret) {
1823 fprintf(err, "[error] %s in %s:%d\n", __func__,
1824 __FILE__, __LINE__);
1825 goto error;
1826 }
1827 BT_PUT(copy_field);
1828 }
1829 BT_PUT(field_type);
1830 BT_PUT(field);
1831 }
1832
1833 ret = 0;
1834 goto end;
1835
1836error:
1837 ret = -1;
1838end:
08b6e8e8 1839 bt_put(event_context_type);
4f45f9bb
JD		 1840 bt_put(writer_event_context_type);
1841 bt_put(writer_event_context);
1842 bt_put(field);
1843 bt_put(copy_field);
1844 bt_put(debug_field);
1845 bt_put(field_type);
1846 return ret;
1847}
1848
1849static
1850struct bt_ctf_clock_class *stream_class_get_clock_class(FILE *err,
1851 struct bt_ctf_stream_class *stream_class)
1852{
1853 struct bt_ctf_trace *trace = NULL;
1854 struct bt_ctf_clock_class *clock_class = NULL;
1855
1856 trace = bt_ctf_stream_class_get_trace(stream_class);
1857 if (!trace) {
1858 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1859 __LINE__);
1860 goto end;
1861 }
1862
290b95cc
MD		 1863 if (!bt_ctf_trace_get_clock_class_count(trace)) {
1864 /* No clock. */
1865 goto end;
1866 }
1867
4f45f9bb 1868 /* FIXME multi-clock? */
9ac68eb1 1869 clock_class = bt_ctf_trace_get_clock_class_by_index(trace, 0);
4f45f9bb
JD		 1870
1871 bt_put(trace);
1872
1873end:
1874 return clock_class;
1875}
1876
1877static
1878struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event *event)
1879{
1880 struct bt_ctf_event_class *event_class = NULL;
1881 struct bt_ctf_stream_class *stream_class = NULL;
1882 struct bt_ctf_clock_class *clock_class = NULL;
1883
1884 event_class = bt_ctf_event_get_class(event);
1885 if (!event_class) {
1886 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1887 __LINE__);
1888 goto error;
1889 }
1890
1891 stream_class = bt_ctf_event_class_get_stream_class(event_class);
1892 if (!stream_class) {
1893 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1894 __LINE__);
1895 goto error;
1896 }
1897
1898 clock_class = stream_class_get_clock_class(err, stream_class);
1899 goto end;
1900
1901error:
1902 BT_PUT(clock_class);
1903end:
1904 bt_put(stream_class);
1905 bt_put(event_class);
1906 return clock_class;
1907}
1908
1909static
1910int set_event_clock_value(FILE *err, struct bt_ctf_event *event,
1911 struct bt_ctf_event *writer_event)
1912{
1913 struct bt_ctf_clock_class *clock_class = NULL;
1914 struct bt_ctf_clock_value *clock_value = NULL;
1081db08 1915 int ret = 0;
4f45f9bb
JD		 1916
1917 clock_class = event_get_clock_class(err, event);
1918 if (!clock_class) {
290b95cc
MD		 1919 /* No clock on input trace. */
1920 goto end;
4f45f9bb
JD		 1921 }
1922
1923 clock_value = bt_ctf_event_get_clock_value(event, clock_class);
1924 if (!clock_value) {
1925 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1926 __LINE__);
1927 goto error;
1928 }
1929
1930 /*
1931 * We share the same clocks, so we can assign the clock value to the
1932 * writer event.
1933 */
1934 ret = bt_ctf_event_set_clock_value(writer_event, clock_value);
1935 if (ret) {
1936 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1937 __LINE__);
1938 goto error;
1939 }
1940
1941 ret = 0;
1942 goto end;
1943
1944error:
1945 ret = -1;
1946end:
1947 bt_put(clock_class);
1948 bt_put(clock_value);
1949 return ret;
1950}
1951
1952static
1953struct bt_ctf_event *debug_info_copy_event(FILE *err, struct bt_ctf_event *event,
1954 struct bt_ctf_event_class *writer_event_class,
1955 struct debug_info *debug_info,
1956 struct debug_info_component *component)
1957{
1958 struct bt_ctf_event *writer_event = NULL;
f6f999a3 1959 struct bt_ctf_field *field = NULL, *copy_field = NULL;
4f45f9bb
JD		 1960 int ret;
1961
1962 writer_event = bt_ctf_event_create(writer_event_class);
1963 if (!writer_event) {
1964 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1965 __LINE__);
1966 goto error;
1967 }
1968
1969 ret = set_event_clock_value(err, event, writer_event);
1970 if (ret) {
1971 fprintf(err, "[error] %s in %s:%d\n", __func__,
1972 __FILE__, __LINE__);
1973 goto error;
1974 }
1975
60ef553b 1976 /* Optional field, so it can fail silently. */
4f45f9bb 1977 field = bt_ctf_event_get_header(event);
60ef553b
JD		 1978 if (field) {
1979 ret = ctf_copy_event_header(err, event, writer_event_class,
1980 writer_event, field);
1981 if (ret) {
1982 fprintf(err, "[error] %s in %s:%d\n", __func__,
1983 __FILE__, __LINE__);
1984 goto error;
1985 }
1986 BT_PUT(field);
4f45f9bb 1987 }
4f45f9bb
JD		 1988
1989 /* Optional field, so it can fail silently. */
1990 field = bt_ctf_event_get_stream_event_context(event);
1991 if (field) {
1992 ret = copy_set_debug_info_stream_event_context(err,
1993 field, event, writer_event, debug_info,
1994 component);
1995 if (ret < 0) {
1996 fprintf(err, "[error] %s in %s:%d\n", __func__,
1997 __FILE__, __LINE__);
1998 goto error;
1999 }
2000 BT_PUT(field);
2001 }
2002
2003 /* Optional field, so it can fail silently. */
2004 field = bt_ctf_event_get_event_context(event);
60ef553b
JD		 2005 if (field) {
2006 copy_field = bt_ctf_field_copy(field);
2007 if (!copy_field) {
2008 fprintf(err, "[error] %s in %s:%d\n", __func__,
2009 __FILE__, __LINE__);
2010 goto error;
2011 }
4f45f9bb
JD		 2012 ret = bt_ctf_event_set_event_context(writer_event, copy_field);
2013 if (ret < 0) {
2014 fprintf(err, "[error] %s in %s:%d\n", __func__,
2015 __FILE__, __LINE__);
2016 goto error;
2017 }
2018 BT_PUT(copy_field);
60ef553b 2019 BT_PUT(field);
4f45f9bb 2020 }
4f45f9bb 2021
9ac68eb1 2022 field = bt_ctf_event_get_event_payload(event);
4f45f9bb
JD		 2023 if (!field) {
2024 fprintf(err, "[error] %s in %s:%d\n", __func__,
2025 __FILE__, __LINE__);
2026 goto error;
2027 }
2028 copy_field = bt_ctf_field_copy(field);
2029 if (copy_field) {
9ac68eb1 2030 ret = bt_ctf_event_set_event_payload(writer_event, copy_field);
4f45f9bb
JD		 2031 if (ret < 0) {
2032 fprintf(err, "[error] %s in %s:%d\n", __func__,
2033 __FILE__, __LINE__);
2034 goto error;
2035 }
2036 BT_PUT(copy_field);
2037 }
2038 BT_PUT(field);
2039
2040 goto end;
2041
2042error:
2043 BT_PUT(writer_event);
2044end:
2045 bt_put(copy_field);
2046 bt_put(field);
2047 return writer_event;
2048}
2049
2050BT_HIDDEN
2051struct bt_ctf_event *debug_info_output_event(
2052 struct debug_info_iterator *debug_it,
2053 struct bt_ctf_event *event)
2054{
2055 struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
2056 struct bt_ctf_stream_class *stream_class = NULL, *writer_stream_class = NULL;
2057 struct bt_ctf_event *writer_event = NULL;
f6f999a3 2058 struct bt_ctf_packet *packet = NULL, *writer_packet = NULL;
4f45f9bb 2059 struct bt_ctf_trace *writer_trace = NULL;
504db471
JD		 2060 struct bt_ctf_stream *stream = NULL;
2061 struct debug_info_trace *di_trace;
4f45f9bb
JD		 2062 struct debug_info *debug_info;
2063 const char *event_name;
2064 int int_ret;
2065
2066 event_class = bt_ctf_event_get_class(event);
2067 if (!event_class) {
2068 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2069 __FILE__, __LINE__);
2070 goto error;
2071 }
2072
2073 event_name = bt_ctf_event_class_get_name(event_class);
2074 if (!event_name) {
2075 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2076 __FILE__, __LINE__);
2077 goto error;
2078 }
2079
2080 stream_class = bt_ctf_event_class_get_stream_class(event_class);
2081 if (!stream_class) {
2082 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2083 __FILE__, __LINE__);
2084 goto error;
2085 }
504db471
JD		 2086 stream = bt_ctf_event_get_stream(event);
2087 if (!stream) {
2088 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2089 __FILE__, __LINE__);
2090 goto error;
2091 }
2092 di_trace = lookup_di_trace_from_stream(debug_it, stream);
2093 if (!di_trace) {
2094 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2095 __FILE__, __LINE__);
2096 goto error;
2097 }
4f45f9bb
JD		 2098
2099 writer_stream_class = g_hash_table_lookup(
504db471 2100 di_trace->stream_class_map,
4f45f9bb 2101 (gpointer) stream_class);
504db471 2102 if (!writer_stream_class) {
4f45f9bb
JD		 2103 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2104 __FILE__, __LINE__);
2105 goto error;
2106 }
504db471 2107 bt_get(writer_stream_class);
4f45f9bb
JD		 2108
2109 writer_event_class = get_event_class(debug_it,
2110 writer_stream_class, event_class);
2111 if (!writer_event_class) {
2112 writer_event_class = ctf_copy_event_class(debug_it->err,
2113 event_class);
2114 if (!writer_event_class) {
2115 fprintf(debug_it->err, "[error] %s in %s:%d\n",
2116 __func__, __FILE__, __LINE__);
2117 goto error;
2118 }
2119 int_ret = bt_ctf_stream_class_add_event_class(
2120 writer_stream_class, writer_event_class);
2121 if (int_ret) {
2122 fprintf(debug_it->err, "[error] %s in %s:%d\n",
2123 __func__, __FILE__, __LINE__);
2124 goto error;
2125 }
2126 }
2127
2128 writer_trace = bt_ctf_stream_class_get_trace(writer_stream_class);
2129 if (!writer_trace) {
2130 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2131 __FILE__, __LINE__);
2132 goto error;
2133 }
2134
504db471 2135 debug_info = get_trace_debug_info(debug_it, writer_trace, di_trace);
4f45f9bb
JD		 2136 if (debug_info) {
2137 debug_info_handle_event(debug_it->err, event, debug_info);
2138 }
2139
2140 writer_event = debug_info_copy_event(debug_it->err, event,
2141 writer_event_class, debug_info,
2142 debug_it->debug_info_component);
2143 if (!writer_event) {
2144 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2145 __FILE__, __LINE__);
2146 fprintf(debug_it->err, "[error] Failed to copy event %s\n",
2147 bt_ctf_event_class_get_name(writer_event_class));
2148 goto error;
2149 }
2150
2151 packet = bt_ctf_event_get_packet(event);
2152 if (!packet) {
2153 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2154 __FILE__, __LINE__);
2155 goto error;
2156 }
2157
504db471 2158 writer_packet = lookup_packet(debug_it, packet, di_trace);
4f45f9bb
JD		 2159 if (!writer_packet) {
2160 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2161 __FILE__, __LINE__);
2162 goto error;
2163 }
2164 bt_get(writer_packet);
2165
2166 int_ret = bt_ctf_event_set_packet(writer_event, writer_packet);
2167 if (int_ret < 0) {
2168 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2169 __FILE__, __LINE__);
2170 fprintf(debug_it->err, "[error] Failed to append event %s\n",
2171 bt_ctf_event_class_get_name(writer_event_class));
2172 goto error;
2173 }
2174
2175 /* Keep the reference on the writer event */
2176 goto end;
2177
2178error:
2179 BT_PUT(writer_event);
2180
2181end:
504db471 2182 bt_put(stream);
4f45f9bb
JD		 2183 bt_put(writer_trace);
2184 bt_put(writer_packet);
2185 bt_put(packet);
2186 bt_put(writer_event_class);
2187 bt_put(writer_stream_class);
2188 bt_put(stream_class);
2189 bt_put(event_class);
2190 return writer_event;
2191}
BabelTrace - Trace Format Babel Tower
This page took 0.148096 seconds and 4 git commands to generate.