projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: remove listener check
[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;
870
871 writer_packet = bt_ctf_packet_create(writer_stream);
872 if (!writer_packet) {
873 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
874 __FILE__, __LINE__);
875 goto end;
876 }
504db471 877 g_hash_table_insert(di_trace->packet_map, (gpointer) packet, writer_packet);
4f45f9bb
JD		 878
879end:
880 return writer_packet;
881}
882
883static
884int add_debug_info_fields(FILE *err,
885 struct bt_ctf_field_type *writer_event_context_type,
886 struct debug_info_component *component)
887{
888 struct bt_ctf_field_type *ip_field = NULL, *debug_field_type = NULL,
889 *bin_field_type = NULL, *func_field_type = NULL,
890 *src_field_type = NULL;
891 int ret = 0;
892
893 ip_field = bt_ctf_field_type_structure_get_field_type_by_name(
894 writer_event_context_type, "_ip");
895 /* No ip field, so no debug info. */
896 if (!ip_field) {
897 goto end;
898 }
899 BT_PUT(ip_field);
900
901 debug_field_type = bt_ctf_field_type_structure_get_field_type_by_name(
902 writer_event_context_type,
903 component->arg_debug_info_field_name);
904 /* Already existing debug_info field, no need to add it. */
905 if (debug_field_type) {
906 goto end;
907 }
908
909 debug_field_type = bt_ctf_field_type_structure_create();
910 if (!debug_field_type) {
911 fprintf(err, "[error] %s in %s:%d\n", __func__,
912 __FILE__, __LINE__);
913 goto error;
914 }
915
916 bin_field_type = bt_ctf_field_type_string_create();
917 if (!bin_field_type) {
918 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
919 __LINE__);
920 goto error;
921 }
922
923 func_field_type = bt_ctf_field_type_string_create();
924 if (!func_field_type) {
925 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
926 __LINE__);
927 goto error;
928 }
929
930 src_field_type = bt_ctf_field_type_string_create();
931 if (!src_field_type) {
932 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
933 __LINE__);
934 goto error;
935 }
936
937 ret = bt_ctf_field_type_structure_add_field(debug_field_type,
938 bin_field_type, "bin");
939 if (ret) {
940 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
941 __LINE__);
942 goto error;
943 }
944
945 ret = bt_ctf_field_type_structure_add_field(debug_field_type,
946 func_field_type, "func");
947 if (ret) {
948 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
949 __LINE__);
950 goto error;
951 }
952
953 ret = bt_ctf_field_type_structure_add_field(debug_field_type,
954 src_field_type, "src");
955 if (ret) {
956 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
957 __LINE__);
958 goto error;
959 }
960
961 ret = bt_ctf_field_type_structure_add_field(writer_event_context_type,
962 debug_field_type, component->arg_debug_info_field_name);
963 if (ret) {
964 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
965 __LINE__);
966 goto error;
967 }
968
969 ret = 0;
970 goto end;
971
972error:
973 BT_PUT(debug_field_type);
974 ret = -1;
975end:
976 bt_put(src_field_type);
977 bt_put(func_field_type);
978 bt_put(bin_field_type);
979 bt_put(debug_field_type);
980 return ret;
981}
982
983static
984int create_debug_info_event_context_type(FILE *err,
985 struct bt_ctf_field_type *event_context_type,
986 struct bt_ctf_field_type *writer_event_context_type,
987 struct debug_info_component *component)
988{
989 int ret, nr_fields, i;
990
991 nr_fields = bt_ctf_field_type_structure_get_field_count(event_context_type);
992 for (i = 0; i < nr_fields; i++) {
993 struct bt_ctf_field_type *field_type = NULL;
994 const char *field_name;
995
996 if (bt_ctf_field_type_structure_get_field(event_context_type,
997 &field_name, &field_type, i) < 0) {
998 fprintf(err, "[error] %s in %s:%d\n", __func__,
999 __FILE__, __LINE__);
1000 goto error;
1001 }
1002
1003 ret = bt_ctf_field_type_structure_add_field(writer_event_context_type,
1004 field_type, field_name);
1005 BT_PUT(field_type);
1006 if (ret) {
1007 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1008 __LINE__);
1009 goto error;
1010 }
1011 }
1012
1013 ret = add_debug_info_fields(err, writer_event_context_type,
1014 component);
1015 goto end;
1016
1017error:
1018 ret = -1;
1019end:
1020 return ret;
1021}
1022
1023static
1024struct bt_ctf_stream_class *copy_stream_class_debug_info(FILE *err,
1025 struct bt_ctf_stream_class *stream_class,
1026 struct bt_ctf_trace *writer_trace,
1027 struct debug_info_component *component)
1028{
1029 struct bt_ctf_field_type *type = NULL;
1030 struct bt_ctf_stream_class *writer_stream_class = NULL;
1031 struct bt_ctf_field_type *writer_event_context_type = NULL;
1032 int ret_int;
1033 const char *name = bt_ctf_stream_class_get_name(stream_class);
1034
1035 if (strlen(name) == 0) {
1036 name = NULL;
1037 }
1038
1039 writer_stream_class = bt_ctf_stream_class_create(name);
1040 if (!writer_stream_class) {
1041 fprintf(err, "[error] %s in %s:%d\n",
1042 __func__, __FILE__, __LINE__);
1043 goto error;
1044 }
1045
1046 type = bt_ctf_stream_class_get_packet_context_type(stream_class);
1047 if (!type) {
1048 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1049 __LINE__);
1050 goto error;
1051 }
1052
1053 ret_int = bt_ctf_stream_class_set_packet_context_type(
1054 writer_stream_class, type);
1055 if (ret_int < 0) {
1056 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1057 __LINE__);
1058 goto error;
1059 }
1060 BT_PUT(type);
1061
1062 type = bt_ctf_stream_class_get_event_header_type(stream_class);
1063 if (!type) {
1064 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1065 __LINE__);
1066 goto error;
1067 }
1068
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);
1077
1078 type = bt_ctf_stream_class_get_event_context_type(stream_class);
1079 if (type) {
1080 writer_event_context_type = bt_ctf_field_type_structure_create();
1081 if (!writer_event_context_type) {
1082 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1083 __LINE__);
1084 goto error;
1085 }
1086 ret_int = create_debug_info_event_context_type(err, type,
1087 writer_event_context_type, component);
1088 if (ret_int) {
1089 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1090 __LINE__);
1091 goto error;
1092 }
1093 BT_PUT(type);
1094
1095 ret_int = bt_ctf_stream_class_set_event_context_type(
1096 writer_stream_class, writer_event_context_type);
1097 if (ret_int < 0) {
1098 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1099 __LINE__);
1100 goto error;
1101 }
1102 BT_PUT(writer_event_context_type);
1103 }
1104
1105 goto end;
1106
1107error:
1108 BT_PUT(writer_stream_class);
1109end:
1110 bt_put(writer_event_context_type);
1111 bt_put(type);
1112 return writer_stream_class;
1113}
1114
1115/*
1116 * Add the original clock classes to the new trace, we do not need to copy
1117 * them, and if we did, we would have to manually inspect the stream class
1118 * to update the integers mapping to a clock.
1119 */
1120static
1121int add_clock_classes(FILE *err, struct bt_ctf_trace *writer_trace,
1122 struct bt_ctf_stream_class *writer_stream_class,
1123 struct bt_ctf_trace *trace)
1124{
1125 int ret, clock_class_count, i;
1126
1127 clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
1128
1129 for (i = 0; i < clock_class_count; i++) {
1130 struct bt_ctf_clock_class *clock_class =
9ac68eb1 1131 bt_ctf_trace_get_clock_class_by_index(trace, i);
4f45f9bb
JD		 1132
1133 if (!clock_class) {
1134 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1135 __LINE__);
1136 goto error;
1137 }
1138
1139 ret = bt_ctf_trace_add_clock_class(writer_trace, clock_class);
1140 BT_PUT(clock_class);
1141 if (ret != 0) {
1142 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1143 __LINE__);
1144 goto error;
1145 }
1146 }
1147
1148 ret = 0;
1149 goto end;
1150
1151error:
1152 ret = -1;
1153end:
1154 return ret;
1155
1156}
1157
1158static
1159struct bt_ctf_stream_class *insert_new_stream_class(
1160 struct debug_info_iterator *debug_it,
1161 struct bt_ctf_stream_class *stream_class)
1162{
1163 struct bt_ctf_stream_class *writer_stream_class = NULL;
1164 struct bt_ctf_trace *trace, *writer_trace = NULL;
504db471 1165 struct debug_info_trace *di_trace;
4f45f9bb
JD		 1166 enum bt_component_status ret;
1167 int int_ret;
1168
1169 trace = bt_ctf_stream_class_get_trace(stream_class);
1170 if (!trace) {
1171 fprintf(debug_it->err,
1172 "[error] %s in %s:%d\n", __func__, __FILE__,
1173 __LINE__);
1174 goto error;
1175 }
1176
504db471
JD		 1177 di_trace = lookup_trace(debug_it, trace);
1178 if (!di_trace) {
1179 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1180 __FILE__, __LINE__);
1181 ret = BT_COMPONENT_STATUS_ERROR;
1182 goto error;
4f45f9bb 1183 }
504db471 1184 writer_trace = di_trace->writer_trace;
4f45f9bb
JD		 1185 bt_get(writer_trace);
1186
1187 writer_stream_class = copy_stream_class_debug_info(debug_it->err, stream_class,
1188 writer_trace, debug_it->debug_info_component);
1189 if (!writer_stream_class) {
1190 fprintf(debug_it->err, "[error] Failed to copy stream class\n");
1191 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1192 __func__, __FILE__, __LINE__);
1193 goto error;
1194 }
1195
1196 int_ret = bt_ctf_trace_add_stream_class(writer_trace, writer_stream_class);
1197 if (int_ret) {
1198 fprintf(debug_it->err,
1199 "[error] %s in %s:%d\n", __func__, __FILE__,
1200 __LINE__);
1201 goto error;
1202 }
1203
1204 ret = add_clock_classes(debug_it->err, writer_trace,
1205 writer_stream_class, trace);
1206 if (ret != BT_COMPONENT_STATUS_OK) {
1207 fprintf(debug_it->err,
1208 "[error] %s in %s:%d\n", __func__, __FILE__,
1209 __LINE__);
1210 goto error;
1211 }
4f45f9bb 1212
504db471 1213 g_hash_table_insert(di_trace->stream_class_map,
4f45f9bb
JD		 1214 (gpointer) stream_class, writer_stream_class);
1215
1216 goto end;
1217
1218error:
1219 BT_PUT(writer_stream_class);
1220end:
1221 bt_put(trace);
1222 bt_put(writer_trace);
1223 return writer_stream_class;
1224}
1225
1226static
1227struct bt_ctf_stream *insert_new_stream(
1228 struct debug_info_iterator *debug_it,
504db471
JD		 1229 struct bt_ctf_stream *stream,
1230 struct debug_info_trace *di_trace)
4f45f9bb
JD		 1231{
1232 struct bt_ctf_stream *writer_stream = NULL;
504db471 1233 struct bt_ctf_stream_class *stream_class = NULL;
4f45f9bb
JD		 1234 struct bt_ctf_stream_class *writer_stream_class = NULL;
1235
504db471
JD		 1236 stream_class = bt_ctf_stream_get_class(stream);
1237 if (!stream_class) {
1238 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1239 __func__, __FILE__, __LINE__);
1240 goto error;
1241 }
1242
4f45f9bb 1243 writer_stream_class = g_hash_table_lookup(
504db471 1244 di_trace->stream_class_map,
4f45f9bb
JD		 1245 (gpointer) stream_class);
1246
1247 if (!writer_stream_class) {
1248 writer_stream_class = insert_new_stream_class(debug_it,
1249 stream_class);
1250 if (!writer_stream_class) {
1251 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1252 __func__, __FILE__, __LINE__);
1253 goto error;
1254 }
1255 }
1256 bt_get(writer_stream_class);
1257
1258 writer_stream = bt_ctf_stream_create(writer_stream_class,
1259 bt_ctf_stream_get_name(stream));
1260 if (!writer_stream) {
1261 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1262 __func__, __FILE__, __LINE__);
1263 goto error;
1264 }
1265
504db471 1266 g_hash_table_insert(di_trace->stream_map, (gpointer) stream,
4f45f9bb
JD		 1267 writer_stream);
1268
1269 goto end;
1270
1271error:
1272 BT_PUT(writer_stream);
1273end:
504db471 1274 bt_put(stream_class);
4f45f9bb
JD		 1275 bt_put(writer_stream_class);
1276 return writer_stream;
1277}
1278
1279static
1280struct bt_ctf_stream *lookup_stream(struct debug_info_iterator *debug_it,
504db471
JD		 1281 struct bt_ctf_stream *stream,
1282 struct debug_info_trace *di_trace)
4f45f9bb
JD		 1283{
1284 return (struct bt_ctf_stream *) g_hash_table_lookup(
504db471 1285 di_trace->stream_map, (gpointer) stream);
4f45f9bb
JD		 1286}
1287
1288static
1289struct bt_ctf_event_class *get_event_class(struct debug_info_iterator *debug_it,
1290 struct bt_ctf_stream_class *writer_stream_class,
1291 struct bt_ctf_event_class *event_class)
1292{
a9f0d01b
PP		 1293 return bt_ctf_stream_class_get_event_class_by_id(writer_stream_class,
1294 bt_ctf_event_class_get_id(event_class));
4f45f9bb
JD		 1295}
1296
504db471
JD		 1297static
1298struct debug_info_trace *lookup_di_trace_from_stream(
1299 struct debug_info_iterator *debug_it,
1300 struct bt_ctf_stream *stream)
1301{
1302 struct bt_ctf_stream_class *stream_class = NULL;
1303 struct bt_ctf_trace *trace = NULL;
1304 struct debug_info_trace *di_trace = NULL;
1305
1306 stream_class = bt_ctf_stream_get_class(stream);
1307 if (!stream_class) {
1308 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1309 __func__, __FILE__, __LINE__);
1310 goto end;
1311 }
1312
1313 trace = bt_ctf_stream_class_get_trace(stream_class);
1314 if (!trace) {
1315 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1316 __func__, __FILE__, __LINE__);
1317 goto end;
1318 }
1319
1320 di_trace = (struct debug_info_trace *) g_hash_table_lookup(
1321 debug_it->trace_map, (gpointer) trace);
1322
1323end:
1324 BT_PUT(stream_class);
1325 BT_PUT(trace);
1326 return di_trace;
1327}
1328
4f45f9bb
JD		 1329static
1330struct bt_ctf_stream *get_writer_stream(
1331 struct debug_info_iterator *debug_it,
1332 struct bt_ctf_packet *packet, struct bt_ctf_stream *stream)
1333{
1334 struct bt_ctf_stream_class *stream_class = NULL;
1335 struct bt_ctf_stream *writer_stream = NULL;
504db471 1336 struct debug_info_trace *di_trace = NULL;
4f45f9bb
JD		 1337
1338 stream_class = bt_ctf_stream_get_class(stream);
1339 if (!stream_class) {
1340 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1341 __func__, __FILE__, __LINE__);
1342 goto error;
1343 }
1344
504db471
JD		 1345 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1346 if (!di_trace) {
1347 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1348 __func__, __FILE__, __LINE__);
1349 goto error;
1350 }
1351
1352 writer_stream = lookup_stream(debug_it, stream, di_trace);
4f45f9bb 1353 if (!writer_stream) {
504db471
JD		 1354 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1355 __func__, __FILE__, __LINE__);
1356 goto error;
4f45f9bb
JD		 1357 }
1358 bt_get(writer_stream);
1359
1360 goto end;
1361
1362error:
1363 BT_PUT(writer_stream);
1364end:
1365 bt_put(stream_class);
1366 return writer_stream;
1367}
1368
1369BT_HIDDEN
1370struct bt_ctf_packet *debug_info_new_packet(
1371 struct debug_info_iterator *debug_it,
1372 struct bt_ctf_packet *packet)
1373{
1374 struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
1375 struct bt_ctf_field *writer_packet_context = NULL;
1376 struct bt_ctf_packet *writer_packet = NULL;
504db471 1377 struct debug_info_trace *di_trace;
4f45f9bb
JD		 1378 int int_ret;
1379
1380 stream = bt_ctf_packet_get_stream(packet);
1381 if (!stream) {
1382 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1383 __func__, __FILE__, __LINE__);
1384 goto error;
1385 }
1386
1387 writer_stream = get_writer_stream(debug_it, packet, stream);
1388 if (!writer_stream) {
1389 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1390 __func__, __FILE__, __LINE__);
1391 goto error;
1392 }
1393
504db471
JD		 1394 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1395 if (!di_trace) {
1396 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1397 __FILE__, __LINE__);
1398 goto error;
1399 }
1400
4f45f9bb
JD		 1401 /*
1402 * If a packet was already opened, close it and remove it from
1403 * the HT.
1404 */
504db471 1405 writer_packet = lookup_packet(debug_it, packet, di_trace);
4f45f9bb 1406 if (writer_packet) {
504db471 1407 g_hash_table_remove(di_trace->packet_map, packet);
4f45f9bb
JD		 1408 BT_PUT(writer_packet);
1409 }
1410
504db471
JD		 1411 writer_packet = insert_new_packet(debug_it, packet, writer_stream,
1412 di_trace);
4f45f9bb
JD		 1413 if (!writer_packet) {
1414 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1415 __func__, __FILE__, __LINE__);
1416 goto error;
1417 }
4f45f9bb
JD		 1418
1419 writer_packet_context = ctf_copy_packet_context(debug_it->err, packet,
79697a58 1420 writer_stream);
4f45f9bb
JD		 1421 if (!writer_packet_context) {
1422 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1423 __func__, __FILE__, __LINE__);
1424 goto error;
1425 }
1426
1427 int_ret = bt_ctf_packet_set_context(writer_packet, writer_packet_context);
1428 if (int_ret) {
1429 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1430 __func__, __FILE__, __LINE__);
1431 goto error;
1432 }
1c78e839
JD		 1433
1434 bt_get(writer_packet);
4f45f9bb
JD		 1435 goto end;
1436
1437error:
1438
1439end:
1440 bt_put(writer_packet_context);
1441 bt_put(writer_stream);
1442 bt_put(stream);
1443 return writer_packet;
1444}
1445
1446BT_HIDDEN
1447struct bt_ctf_packet *debug_info_close_packet(
1448 struct debug_info_iterator *debug_it,
1449 struct bt_ctf_packet *packet)
1450{
1451 struct bt_ctf_packet *writer_packet = NULL;
504db471
JD		 1452 struct bt_ctf_stream *stream = NULL;
1453 struct debug_info_trace *di_trace;
1454
1455 stream = bt_ctf_packet_get_stream(packet);
1456 if (!stream) {
1457 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1458 __FILE__, __LINE__);
1459 goto end;
1460 }
1461
1462 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1463 if (!di_trace) {
1464 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1465 __FILE__, __LINE__);
1466 goto end;
1467 }
4f45f9bb 1468
504db471 1469 writer_packet = lookup_packet(debug_it, packet, di_trace);
4f45f9bb
JD		 1470 if (!writer_packet) {
1471 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1472 __func__, __FILE__, __LINE__);
1473 goto end;
1474 }
1c78e839 1475 bt_get(writer_packet);
504db471 1476 g_hash_table_remove(di_trace->packet_map, packet);
4f45f9bb
JD		 1477
1478end:
504db471 1479 bt_put(stream);
4f45f9bb
JD		 1480 return writer_packet;
1481}
1482
504db471
JD		 1483BT_HIDDEN
1484struct bt_ctf_stream *debug_info_stream_begin(
1485 struct debug_info_iterator *debug_it,
1486 struct bt_ctf_stream *stream)
1487{
cb0a5cf8 1488 struct bt_ctf_stream *writer_stream = NULL;
1c78e839 1489 enum debug_info_stream_state *state;
504db471
JD		 1490 struct debug_info_trace *di_trace = NULL;
1491
1492 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1493 if (!di_trace) {
1494 di_trace = insert_new_trace(debug_it, stream);
1495 if (!di_trace) {
1496 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1497 __func__, __FILE__, __LINE__);
1c78e839 1498 goto error;
504db471
JD		 1499 }
1500 }
1501
1c78e839
JD		 1502 /* Set the stream as active */
1503 state = g_hash_table_lookup(di_trace->stream_states, stream);
1504 if (!state) {
1505 if (di_trace->trace_static) {
1506 fprintf(debug_it->err, "[error] Adding a new stream "
1507 "on a static trace\n");
1508 goto error;
1509 }
1510 state = insert_new_stream_state(debug_it, di_trace,
1511 stream);
ec273a88
JD		 1512 if (!state) {
1513 fprintf(debug_it->err, "[error] Adding a new stream "
1514 "on a static trace\n");
1515 goto error;
1516 }
1c78e839
JD		 1517 }
1518 if (*state != DEBUG_INFO_UNKNOWN_STREAM) {
1519 fprintf(debug_it->err, "[error] Unexpected stream state %d\n",
1520 *state);
1521 goto error;
1522 }
1523 *state = DEBUG_INFO_ACTIVE_STREAM;
1524
cb0a5cf8
JD		 1525 writer_stream = lookup_stream(debug_it, stream, di_trace);
1526 if (!writer_stream) {
1527 writer_stream = insert_new_stream(debug_it, stream, di_trace);
1528 }
1c78e839 1529 bt_get(writer_stream);
504db471 1530
1c78e839
JD		 1531 goto end;
1532
1533error:
1534 BT_PUT(writer_stream);
504db471
JD		 1535end:
1536 return writer_stream;
1537}
1538
4f45f9bb
JD		 1539BT_HIDDEN
1540struct bt_ctf_stream *debug_info_stream_end(struct debug_info_iterator *debug_it,
1541 struct bt_ctf_stream *stream)
1542{
0bb3da02 1543 struct bt_ctf_stream *writer_stream = NULL;
504db471 1544 struct debug_info_trace *di_trace = NULL;
1c78e839 1545 enum debug_info_stream_state *state;
504db471
JD		 1546
1547 di_trace = lookup_di_trace_from_stream(debug_it, stream);
1548 if (!di_trace) {
1549 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1550 __func__, __FILE__, __LINE__);
1c78e839 1551 goto error;
504db471 1552 }
4f45f9bb 1553
504db471 1554 writer_stream = lookup_stream(debug_it, stream, di_trace);
4f45f9bb
JD		 1555 if (!writer_stream) {
1556 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1557 __func__, __FILE__, __LINE__);
1c78e839 1558 goto error;
4f45f9bb 1559 }
1c78e839
JD		 1560 /*
1561 * Take the ref on the stream and keep it until the notification
1562 * is created.
1563 */
34101229 1564 bt_get(writer_stream);
1c78e839
JD		 1565
1566 state = g_hash_table_lookup(di_trace->stream_states, stream);
1567 if (*state != DEBUG_INFO_ACTIVE_STREAM) {
1568 fprintf(debug_it->err, "[error] Unexpected stream "
1569 "state %d\n", *state);
1570 goto error;
1571 }
1572 *state = DEBUG_INFO_COMPLETED_STREAM;
1573
504db471 1574 g_hash_table_remove(di_trace->stream_map, stream);
4f45f9bb 1575
1c78e839
JD		 1576 if (di_trace->trace_static) {
1577 int trace_completed = 1;
1578
1579 g_hash_table_foreach(di_trace->stream_states,
1580 check_completed_trace, &trace_completed);
1581 if (trace_completed) {
1582 debug_info_close_trace(debug_it, di_trace);
1583 g_hash_table_remove(debug_it->trace_map,
1584 di_trace->trace);
1585 }
1586 }
1587
1588 goto end;
1589
1590error:
1591 BT_PUT(writer_stream);
1592
4f45f9bb
JD		 1593end:
1594 return writer_stream;
1595}
1596
1597static
1598struct debug_info_source *lookup_debug_info(FILE *err,
1599 struct bt_ctf_event *event,
1600 struct debug_info *debug_info)
1601{
1602 int64_t vpid;
1603 uint64_t ip;
1604 struct debug_info_source *dbg_info_src = NULL;
1605 int ret;
1606
1607 ret = get_stream_event_context_int_field_value(err, event,
1608 "_vpid", &vpid);
1609 if (ret) {
1610 goto end;
1611 }
1612
1613 ret = get_stream_event_context_unsigned_int_field_value(err, event,
1614 "_ip", &ip);
1615 if (ret) {
1616 goto end;
1617 }
1618
1619 /* Get debug info for this context. */
1620 dbg_info_src = debug_info_query(debug_info, vpid, ip);
1621
1622end:
1623 return dbg_info_src;
1624}
1625
1626static
1627int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field,
1628 struct debug_info_source *dbg_info_src,
1629 struct debug_info_component *component)
1630{
2afcfbfb 1631 int i, nr_fields, ret = 0;
4f45f9bb
JD		 1632 struct bt_ctf_field_type *debug_field_type = NULL;
1633 struct bt_ctf_field *field = NULL;
1634 struct bt_ctf_field_type *field_type = NULL;
1635
1636 debug_field_type = bt_ctf_field_get_type(debug_field);
1637 if (!debug_field_type) {
1638 fprintf(err, "[error] %s in %s:%d\n", __func__,
1639 __FILE__, __LINE__);
1640 goto error;
1641 }
1642
1643 nr_fields = bt_ctf_field_type_structure_get_field_count(debug_field_type);
1644 for (i = 0; i < nr_fields; i++) {
1645 const char *field_name;
1646
1647 if (bt_ctf_field_type_structure_get_field(debug_field_type,
1648 &field_name, &field_type, i) < 0) {
1649 fprintf(err, "[error] %s in %s:%d\n", __func__,
1650 __FILE__, __LINE__);
1651 goto error;
1652 }
1653 BT_PUT(field_type);
1654
1655 field = bt_ctf_field_structure_get_field_by_index(debug_field, i);
1656 if (!strcmp(field_name, "bin")) {
1657 if (dbg_info_src && dbg_info_src->bin_path) {
1658 GString *tmp = g_string_new(NULL);
1659
1660 if (component->arg_full_path) {
1661 g_string_printf(tmp, "%s%s",
1662 dbg_info_src->bin_path,
1663 dbg_info_src->bin_loc);
1664 } else {
1665 g_string_printf(tmp, "%s%s",
1666 dbg_info_src->short_bin_path,
1667 dbg_info_src->bin_loc);
1668 }
1669 ret = bt_ctf_field_string_set_value(field, tmp->str);
1670 g_string_free(tmp, true);
1671 } else {
1672 ret = bt_ctf_field_string_set_value(field, "");
1673 }
1674 } else if (!strcmp(field_name, "func")) {
1675 if (dbg_info_src && dbg_info_src->func) {
1676 ret = bt_ctf_field_string_set_value(field,
1677 dbg_info_src->func);
1678 } else {
1679 ret = bt_ctf_field_string_set_value(field, "");
1680 }
1681 } else if (!strcmp(field_name, "src")) {
1682 if (dbg_info_src && dbg_info_src->src_path) {
1683 GString *tmp = g_string_new(NULL);
1684
1685 if (component->arg_full_path) {
1686 g_string_printf(tmp, "%s:%" PRId64,
1687 dbg_info_src->src_path,
1688 dbg_info_src->line_no);
1689 } else {
1690 g_string_printf(tmp, "%s:%" PRId64,
1691 dbg_info_src->short_src_path,
1692 dbg_info_src->line_no);
1693 }
1694 ret = bt_ctf_field_string_set_value(field, tmp->str);
1695 g_string_free(tmp, true);
1696 } else {
1697 ret = bt_ctf_field_string_set_value(field, "");
1698 }
1699 }
1700 BT_PUT(field);
1701 if (ret) {
1702 fprintf(err, "[error] %s in %s:%d\n", __func__,
1703 __FILE__, __LINE__);
1704 goto error;
1705 }
1706 }
1707 ret = 0;
1708 goto end;
1709
1710error:
1711 ret = -1;
1712end:
1713 bt_put(field_type);
1714 bt_put(field);
1715 bt_put(debug_field_type);
1716 return ret;
1717}
1718
1719static
1720int copy_set_debug_info_stream_event_context(FILE *err,
1721 struct bt_ctf_field *event_context,
1722 struct bt_ctf_event *event,
1723 struct bt_ctf_event *writer_event,
1724 struct debug_info *debug_info,
1725 struct debug_info_component *component)
1726{
08b6e8e8
JD		 1727 struct bt_ctf_field_type *writer_event_context_type = NULL,
1728 *event_context_type = NULL;
4f45f9bb
JD		 1729 struct bt_ctf_field *writer_event_context = NULL;
1730 struct bt_ctf_field *field = NULL, *copy_field = NULL, *debug_field = NULL;
1731 struct bt_ctf_field_type *field_type = NULL;
1732 struct debug_info_source *dbg_info_src;
1733 int ret, nr_fields, i;
1734
1735 writer_event_context = bt_ctf_event_get_stream_event_context(writer_event);
1736 if (!writer_event_context) {
1737 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
1738 goto error;
1739 }
1740
1741 writer_event_context_type = bt_ctf_field_get_type(writer_event_context);
1742 if (!writer_event_context_type) {
1743 fprintf(err, "[error] %s in %s:%d\n", __func__,
1744 __FILE__, __LINE__);
1745 goto error;
1746 }
1747
08b6e8e8
JD		 1748 event_context_type = bt_ctf_field_get_type(event_context);
1749 if (!event_context_type) {
1750 fprintf(err, "[error] %s in %s:%d\n", __func__,
1751 __FILE__, __LINE__);
1752 goto error;
1753 }
1754
4f45f9bb
JD		 1755 /*
1756 * If it is not a structure, we did not modify it to add the debug info
1757 * fields, so just assign it as is.
1758 */
1487a16a 1759 if (bt_ctf_field_type_get_type_id(writer_event_context_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
4f45f9bb
JD		 1760 ret = bt_ctf_event_set_event_context(writer_event, event_context);
1761 goto end;
1762 }
1763
1764 dbg_info_src = lookup_debug_info(err, event, debug_info);
1765
1766 nr_fields = bt_ctf_field_type_structure_get_field_count(writer_event_context_type);
1767 for (i = 0; i < nr_fields; i++) {
1768 const char *field_name;
1769
1770 if (bt_ctf_field_type_structure_get_field(writer_event_context_type,
1771 &field_name, &field_type, i) < 0) {
1772 fprintf(err, "[error] %s in %s:%d\n", __func__,
1773 __FILE__, __LINE__);
1774 goto error;
1775 }
1776
08b6e8e8
JD		 1777 /*
1778 * Prevent illegal access in the event_context.
1779 */
1780 if (i < bt_ctf_field_type_structure_get_field_count(event_context_type)) {
1781 field = bt_ctf_field_structure_get_field_by_index(event_context, i);
1782 }
4f45f9bb
JD		 1783 /*
1784 * The debug_info field, only exists in the writer event or
1785 * if it was set by a earlier pass of the debug_info plugin.
4f45f9bb
JD		 1786 */
1787 if (!strcmp(field_name, component->arg_debug_info_field_name) &&
1788 !field) {
1789 debug_field = bt_ctf_field_structure_get_field_by_index(
1790 writer_event_context, i);
1791 if (!debug_field) {
1792 fprintf(err, "[error] %s in %s:%d\n", __func__,
1793 __FILE__, __LINE__);
1794 goto error;
1795 }
1796 ret = set_debug_info_field(err, debug_field,
1797 dbg_info_src, component);
1798 if (ret) {
1799 fprintf(err, "[error] %s in %s:%d\n", __func__,
1800 __FILE__, __LINE__);
1801 goto error;
1802 }
1803 BT_PUT(debug_field);
1804 } else {
1805 copy_field = bt_ctf_field_copy(field);
1806 if (!copy_field) {
1807 fprintf(err, "[error] %s in %s:%d\n", __func__,
1808 __FILE__, __LINE__);
1809 goto error;
1810 }
1811
1812 ret = bt_ctf_field_structure_set_field(writer_event_context,
1813 field_name, copy_field);
1814 if (ret) {
1815 fprintf(err, "[error] %s in %s:%d\n", __func__,
1816 __FILE__, __LINE__);
1817 goto error;
1818 }
1819 BT_PUT(copy_field);
1820 }
1821 BT_PUT(field_type);
1822 BT_PUT(field);
1823 }
1824
1825 ret = 0;
1826 goto end;
1827
1828error:
1829 ret = -1;
1830end:
08b6e8e8 1831 bt_put(event_context_type);
4f45f9bb
JD		 1832 bt_put(writer_event_context_type);
1833 bt_put(writer_event_context);
1834 bt_put(field);
1835 bt_put(copy_field);
1836 bt_put(debug_field);
1837 bt_put(field_type);
1838 return ret;
1839}
1840
1841static
1842struct bt_ctf_clock_class *stream_class_get_clock_class(FILE *err,
1843 struct bt_ctf_stream_class *stream_class)
1844{
1845 struct bt_ctf_trace *trace = NULL;
1846 struct bt_ctf_clock_class *clock_class = NULL;
1847
1848 trace = bt_ctf_stream_class_get_trace(stream_class);
1849 if (!trace) {
1850 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1851 __LINE__);
1852 goto end;
1853 }
1854
1855 /* FIXME multi-clock? */
9ac68eb1 1856 clock_class = bt_ctf_trace_get_clock_class_by_index(trace, 0);
4f45f9bb
JD		 1857
1858 bt_put(trace);
1859
1860end:
1861 return clock_class;
1862}
1863
1864static
1865struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event *event)
1866{
1867 struct bt_ctf_event_class *event_class = NULL;
1868 struct bt_ctf_stream_class *stream_class = NULL;
1869 struct bt_ctf_clock_class *clock_class = NULL;
1870
1871 event_class = bt_ctf_event_get_class(event);
1872 if (!event_class) {
1873 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1874 __LINE__);
1875 goto error;
1876 }
1877
1878 stream_class = bt_ctf_event_class_get_stream_class(event_class);
1879 if (!stream_class) {
1880 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1881 __LINE__);
1882 goto error;
1883 }
1884
1885 clock_class = stream_class_get_clock_class(err, stream_class);
1886 goto end;
1887
1888error:
1889 BT_PUT(clock_class);
1890end:
1891 bt_put(stream_class);
1892 bt_put(event_class);
1893 return clock_class;
1894}
1895
1896static
1897int set_event_clock_value(FILE *err, struct bt_ctf_event *event,
1898 struct bt_ctf_event *writer_event)
1899{
1900 struct bt_ctf_clock_class *clock_class = NULL;
1901 struct bt_ctf_clock_value *clock_value = NULL;
1902 int ret;
1903
1904 clock_class = event_get_clock_class(err, event);
1905 if (!clock_class) {
1906 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1907 __LINE__);
1908 goto error;
1909 }
1910
1911 clock_value = bt_ctf_event_get_clock_value(event, clock_class);
1912 if (!clock_value) {
1913 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1914 __LINE__);
1915 goto error;
1916 }
1917
1918 /*
1919 * We share the same clocks, so we can assign the clock value to the
1920 * writer event.
1921 */
1922 ret = bt_ctf_event_set_clock_value(writer_event, clock_value);
1923 if (ret) {
1924 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1925 __LINE__);
1926 goto error;
1927 }
1928
1929 ret = 0;
1930 goto end;
1931
1932error:
1933 ret = -1;
1934end:
1935 bt_put(clock_class);
1936 bt_put(clock_value);
1937 return ret;
1938}
1939
1940static
1941struct bt_ctf_event *debug_info_copy_event(FILE *err, struct bt_ctf_event *event,
1942 struct bt_ctf_event_class *writer_event_class,
1943 struct debug_info *debug_info,
1944 struct debug_info_component *component)
1945{
1946 struct bt_ctf_event *writer_event = NULL;
f6f999a3 1947 struct bt_ctf_field *field = NULL, *copy_field = NULL;
4f45f9bb
JD		 1948 int ret;
1949
1950 writer_event = bt_ctf_event_create(writer_event_class);
1951 if (!writer_event) {
1952 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1953 __LINE__);
1954 goto error;
1955 }
1956
1957 ret = set_event_clock_value(err, event, writer_event);
1958 if (ret) {
1959 fprintf(err, "[error] %s in %s:%d\n", __func__,
1960 __FILE__, __LINE__);
1961 goto error;
1962 }
1963
60ef553b 1964 /* Optional field, so it can fail silently. */
4f45f9bb 1965 field = bt_ctf_event_get_header(event);
60ef553b
JD		 1966 if (field) {
1967 ret = ctf_copy_event_header(err, event, writer_event_class,
1968 writer_event, field);
1969 if (ret) {
1970 fprintf(err, "[error] %s in %s:%d\n", __func__,
1971 __FILE__, __LINE__);
1972 goto error;
1973 }
1974 BT_PUT(field);
4f45f9bb 1975 }
4f45f9bb
JD		 1976
1977 /* Optional field, so it can fail silently. */
1978 field = bt_ctf_event_get_stream_event_context(event);
1979 if (field) {
1980 ret = copy_set_debug_info_stream_event_context(err,
1981 field, event, writer_event, debug_info,
1982 component);
1983 if (ret < 0) {
1984 fprintf(err, "[error] %s in %s:%d\n", __func__,
1985 __FILE__, __LINE__);
1986 goto error;
1987 }
1988 BT_PUT(field);
1989 }
1990
1991 /* Optional field, so it can fail silently. */
1992 field = bt_ctf_event_get_event_context(event);
60ef553b
JD		 1993 if (field) {
1994 copy_field = bt_ctf_field_copy(field);
1995 if (!copy_field) {
1996 fprintf(err, "[error] %s in %s:%d\n", __func__,
1997 __FILE__, __LINE__);
1998 goto error;
1999 }
4f45f9bb
JD		 2000 ret = bt_ctf_event_set_event_context(writer_event, copy_field);
2001 if (ret < 0) {
2002 fprintf(err, "[error] %s in %s:%d\n", __func__,
2003 __FILE__, __LINE__);
2004 goto error;
2005 }
2006 BT_PUT(copy_field);
60ef553b 2007 BT_PUT(field);
4f45f9bb 2008 }
4f45f9bb 2009
9ac68eb1 2010 field = bt_ctf_event_get_event_payload(event);
4f45f9bb
JD		 2011 if (!field) {
2012 fprintf(err, "[error] %s in %s:%d\n", __func__,
2013 __FILE__, __LINE__);
2014 goto error;
2015 }
2016 copy_field = bt_ctf_field_copy(field);
2017 if (copy_field) {
9ac68eb1 2018 ret = bt_ctf_event_set_event_payload(writer_event, copy_field);
4f45f9bb
JD		 2019 if (ret < 0) {
2020 fprintf(err, "[error] %s in %s:%d\n", __func__,
2021 __FILE__, __LINE__);
2022 goto error;
2023 }
2024 BT_PUT(copy_field);
2025 }
2026 BT_PUT(field);
2027
2028 goto end;
2029
2030error:
2031 BT_PUT(writer_event);
2032end:
2033 bt_put(copy_field);
2034 bt_put(field);
2035 return writer_event;
2036}
2037
2038BT_HIDDEN
2039struct bt_ctf_event *debug_info_output_event(
2040 struct debug_info_iterator *debug_it,
2041 struct bt_ctf_event *event)
2042{
2043 struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
2044 struct bt_ctf_stream_class *stream_class = NULL, *writer_stream_class = NULL;
2045 struct bt_ctf_event *writer_event = NULL;
f6f999a3 2046 struct bt_ctf_packet *packet = NULL, *writer_packet = NULL;
4f45f9bb 2047 struct bt_ctf_trace *writer_trace = NULL;
504db471
JD		 2048 struct bt_ctf_stream *stream = NULL;
2049 struct debug_info_trace *di_trace;
4f45f9bb
JD		 2050 struct debug_info *debug_info;
2051 const char *event_name;
2052 int int_ret;
2053
2054 event_class = bt_ctf_event_get_class(event);
2055 if (!event_class) {
2056 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2057 __FILE__, __LINE__);
2058 goto error;
2059 }
2060
2061 event_name = bt_ctf_event_class_get_name(event_class);
2062 if (!event_name) {
2063 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2064 __FILE__, __LINE__);
2065 goto error;
2066 }
2067
2068 stream_class = bt_ctf_event_class_get_stream_class(event_class);
2069 if (!stream_class) {
2070 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2071 __FILE__, __LINE__);
2072 goto error;
2073 }
504db471
JD		 2074 stream = bt_ctf_event_get_stream(event);
2075 if (!stream) {
2076 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2077 __FILE__, __LINE__);
2078 goto error;
2079 }
2080 di_trace = lookup_di_trace_from_stream(debug_it, stream);
2081 if (!di_trace) {
2082 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2083 __FILE__, __LINE__);
2084 goto error;
2085 }
4f45f9bb
JD		 2086
2087 writer_stream_class = g_hash_table_lookup(
504db471 2088 di_trace->stream_class_map,
4f45f9bb 2089 (gpointer) stream_class);
504db471 2090 if (!writer_stream_class) {
4f45f9bb
JD		 2091 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2092 __FILE__, __LINE__);
2093 goto error;
2094 }
504db471 2095 bt_get(writer_stream_class);
4f45f9bb
JD		 2096
2097 writer_event_class = get_event_class(debug_it,
2098 writer_stream_class, event_class);
2099 if (!writer_event_class) {
2100 writer_event_class = ctf_copy_event_class(debug_it->err,
2101 event_class);
2102 if (!writer_event_class) {
2103 fprintf(debug_it->err, "[error] %s in %s:%d\n",
2104 __func__, __FILE__, __LINE__);
2105 goto error;
2106 }
2107 int_ret = bt_ctf_stream_class_add_event_class(
2108 writer_stream_class, writer_event_class);
2109 if (int_ret) {
2110 fprintf(debug_it->err, "[error] %s in %s:%d\n",
2111 __func__, __FILE__, __LINE__);
2112 goto error;
2113 }
2114 }
2115
2116 writer_trace = bt_ctf_stream_class_get_trace(writer_stream_class);
2117 if (!writer_trace) {
2118 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2119 __FILE__, __LINE__);
2120 goto error;
2121 }
2122
504db471 2123 debug_info = get_trace_debug_info(debug_it, writer_trace, di_trace);
4f45f9bb
JD		 2124 if (debug_info) {
2125 debug_info_handle_event(debug_it->err, event, debug_info);
2126 }
2127
2128 writer_event = debug_info_copy_event(debug_it->err, event,
2129 writer_event_class, debug_info,
2130 debug_it->debug_info_component);
2131 if (!writer_event) {
2132 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2133 __FILE__, __LINE__);
2134 fprintf(debug_it->err, "[error] Failed to copy event %s\n",
2135 bt_ctf_event_class_get_name(writer_event_class));
2136 goto error;
2137 }
2138
2139 packet = bt_ctf_event_get_packet(event);
2140 if (!packet) {
2141 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2142 __FILE__, __LINE__);
2143 goto error;
2144 }
2145
504db471 2146 writer_packet = lookup_packet(debug_it, packet, di_trace);
4f45f9bb
JD		 2147 if (!writer_packet) {
2148 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2149 __FILE__, __LINE__);
2150 goto error;
2151 }
2152 bt_get(writer_packet);
2153
2154 int_ret = bt_ctf_event_set_packet(writer_event, writer_packet);
2155 if (int_ret < 0) {
2156 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2157 __FILE__, __LINE__);
2158 fprintf(debug_it->err, "[error] Failed to append event %s\n",
2159 bt_ctf_event_class_get_name(writer_event_class));
2160 goto error;
2161 }
2162
2163 /* Keep the reference on the writer event */
2164 goto end;
2165
2166error:
2167 BT_PUT(writer_event);
2168
2169end:
504db471 2170 bt_put(stream);
4f45f9bb
JD		 2171 bt_put(writer_trace);
2172 bt_put(writer_packet);
2173 bt_put(packet);
2174 bt_put(writer_event_class);
2175 bt_put(writer_stream_class);
2176 bt_put(stream_class);
2177 bt_put(event_class);
2178 return writer_event;
2179}
BabelTrace - Trace Format Babel Tower
This page took 0.115795 seconds and 4 git commands to generate.