configure: re-enable '-Wunused-parameter'
[babeltrace.git] / src / plugins / lttng-utils / debug-info / debug-info.c
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
5 * Copyright (c) 2015 Philippe Proulx <pproulx@efficios.com>
6 * Copyright (c) 2015 Antoine Busque <abusque@efficios.com>
7 * Copyright (c) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 * Copyright (c) 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
9 *
10 * Babeltrace - Debug Information State Tracker
11 */
12
13 #define BT_COMP_LOG_SELF_COMP self_comp
14 #define BT_LOG_OUTPUT_LEVEL log_level
15 #define BT_LOG_TAG "PLUGIN/FLT.LTTNG-UTILS.DEBUG-INFO"
16 #include "logging/comp-logging.h"
17
18 #include <stdbool.h>
19
20 #include <glib.h>
21
22 #include "common/assert.h"
23 #include "common/common.h"
24 #include "fd-cache/fd-cache.h"
25
26 #include "bin-info.h"
27 #include "debug-info.h"
28 #include "trace-ir-data-copy.h"
29 #include "trace-ir-mapping.h"
30 #include "trace-ir-metadata-copy.h"
31 #include "utils.h"
32 #include "plugins/common/param-validation/param-validation.h"
33
34 #define DEFAULT_DEBUG_INFO_FIELD_NAME "debug_info"
35 #define LTTNG_UST_STATEDUMP_PREFIX "lttng_ust"
36
37 struct debug_info_component {
38 bt_logging_level log_level;
39 bt_self_component *self_comp;
40 bt_self_component_filter *self_comp_filter;
41 gchar *arg_debug_dir;
42 gchar *arg_debug_info_field_name;
43 gchar *arg_target_prefix;
44 bt_bool arg_full_path;
45 };
46
47 struct debug_info_msg_iter {
48 bt_logging_level log_level;
49 struct debug_info_component *debug_info_component;
50 bt_self_message_iterator *input_iterator;
51 bt_self_component *self_comp;
52 bt_message_iterator *msg_iter;
53
54 struct trace_ir_maps *ir_maps;
55 /* in_trace -> debug_info_mapping. */
56 GHashTable *debug_info_map;
57
58 struct bt_fd_cache fd_cache;
59 };
60
61 struct debug_info_source {
62 /* Strings are owned by debug_info_source. */
63 gchar *func;
64 /*
65 * Store the line number as a string so that the allocation and
66 * conversion to string is only done once.
67 */
68 gchar *line_no;
69 gchar *src_path;
70 /* short_src_path points inside src_path, no need to free. */
71 const gchar *short_src_path;
72 gchar *bin_path;
73 /* short_bin_path points inside bin_path, no need to free. */
74 const gchar *short_bin_path;
75 /*
76 * Location within the binary. Either absolute (@0x1234) or
77 * relative (+0x4321).
78 */
79 gchar *bin_loc;
80 };
81
82 struct proc_debug_info_sources {
83 /*
84 * Hash table: base address (pointer to uint64_t) to bin info; owned by
85 * proc_debug_info_sources.
86 */
87 GHashTable *baddr_to_bin_info;
88
89 /*
90 * Hash table: IP (pointer to uint64_t) to (struct debug_info_source *);
91 * owned by proc_debug_info_sources.
92 */
93 GHashTable *ip_to_debug_info_src;
94 };
95
96 struct debug_info {
97 bt_logging_level log_level;
98 bt_self_component *self_comp;
99 struct debug_info_component *comp;
100 const bt_trace *input_trace;
101 bt_listener_id destruction_listener_id;
102
103 /*
104 * Hash table of VPIDs (pointer to int64_t) to
105 * (struct proc_debug_info_sources*); owned by debug_info.
106 */
107 GHashTable *vpid_to_proc_dbg_info_src;
108 GQuark q_statedump_bin_info;
109 GQuark q_statedump_debug_link;
110 GQuark q_statedump_build_id;
111 GQuark q_statedump_start;
112 GQuark q_dl_open;
113 GQuark q_lib_load;
114 GQuark q_lib_unload;
115 struct bt_fd_cache *fd_cache; /* Weak ref. Owned by the iterator. */
116 };
117
118 static
119 int debug_info_init(struct debug_info *info)
120 {
121 info->q_statedump_bin_info = g_quark_from_string(
122 "lttng_ust_statedump:bin_info");
123 info->q_statedump_debug_link = g_quark_from_string(
124 "lttng_ust_statedump:debug_link");
125 info->q_statedump_build_id = g_quark_from_string(
126 "lttng_ust_statedump:build_id");
127 info->q_statedump_start = g_quark_from_string(
128 "lttng_ust_statedump:start");
129 info->q_dl_open = g_quark_from_string("lttng_ust_dl:dlopen");
130 info->q_lib_load = g_quark_from_string("lttng_ust_lib:load");
131 info->q_lib_unload = g_quark_from_string("lttng_ust_lib:unload");
132
133 return bin_info_init(info->log_level, info->self_comp);
134 }
135
136 static
137 void debug_info_source_destroy(struct debug_info_source *debug_info_src)
138 {
139 if (!debug_info_src) {
140 return;
141 }
142
143 g_free(debug_info_src->func);
144 g_free(debug_info_src->line_no);
145 g_free(debug_info_src->src_path);
146 g_free(debug_info_src->bin_path);
147 g_free(debug_info_src->bin_loc);
148 g_free(debug_info_src);
149 }
150
151 static
152 struct debug_info_source *debug_info_source_create_from_bin(
153 struct bin_info *bin, uint64_t ip,
154 bt_self_component *self_comp)
155 {
156 int ret;
157 struct debug_info_source *debug_info_src = NULL;
158 struct source_location *src_loc = NULL;
159 bt_logging_level log_level;
160
161 BT_ASSERT(bin);
162
163 log_level = bin->log_level;
164
165 debug_info_src = g_new0(struct debug_info_source, 1);
166
167 if (!debug_info_src) {
168 goto end;
169 }
170
171 /* Lookup function name */
172 ret = bin_info_lookup_function_name(bin, ip, &debug_info_src->func);
173 if (ret) {
174 goto error;
175 }
176
177 /* Can't retrieve src_loc from ELF, or could not find binary, skip. */
178 if (!bin->is_elf_only || !debug_info_src->func) {
179 /* Lookup source location */
180 ret = bin_info_lookup_source_location(bin, ip, &src_loc);
181 if (ret) {
182 BT_COMP_LOGI("Failed to lookup source location: ret=%d", ret);
183 }
184 }
185
186 if (src_loc) {
187 debug_info_src->line_no =
188 g_strdup_printf("%"PRId64, src_loc->line_no);
189 if (!debug_info_src->line_no) {
190 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
191 "Error occurred when setting `line_no` field.");
192 goto error;
193 }
194
195 if (src_loc->filename) {
196 debug_info_src->src_path = g_strdup(src_loc->filename);
197 if (!debug_info_src->src_path) {
198 goto error;
199 }
200
201 debug_info_src->short_src_path = get_filename_from_path(
202 debug_info_src->src_path);
203 }
204 source_location_destroy(src_loc);
205 }
206
207 if (bin->elf_path) {
208 debug_info_src->bin_path = g_strdup(bin->elf_path);
209 if (!debug_info_src->bin_path) {
210 goto error;
211 }
212
213 debug_info_src->short_bin_path = get_filename_from_path(
214 debug_info_src->bin_path);
215
216 ret = bin_info_get_bin_loc(bin, ip, &(debug_info_src->bin_loc));
217 if (ret) {
218 goto error;
219 }
220 }
221
222 end:
223 return debug_info_src;
224
225 error:
226 debug_info_source_destroy(debug_info_src);
227 return NULL;
228 }
229
230 static
231 void proc_debug_info_sources_destroy(
232 struct proc_debug_info_sources *proc_dbg_info_src)
233 {
234 if (!proc_dbg_info_src) {
235 return;
236 }
237
238 if (proc_dbg_info_src->baddr_to_bin_info) {
239 g_hash_table_destroy(proc_dbg_info_src->baddr_to_bin_info);
240 }
241
242 if (proc_dbg_info_src->ip_to_debug_info_src) {
243 g_hash_table_destroy(proc_dbg_info_src->ip_to_debug_info_src);
244 }
245
246 g_free(proc_dbg_info_src);
247 }
248
249 static
250 struct proc_debug_info_sources *proc_debug_info_sources_create(void)
251 {
252 struct proc_debug_info_sources *proc_dbg_info_src = NULL;
253
254 proc_dbg_info_src = g_new0(struct proc_debug_info_sources, 1);
255 if (!proc_dbg_info_src) {
256 goto end;
257 }
258
259 proc_dbg_info_src->baddr_to_bin_info = g_hash_table_new_full(
260 g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
261 (GDestroyNotify) bin_info_destroy);
262 if (!proc_dbg_info_src->baddr_to_bin_info) {
263 goto error;
264 }
265
266 proc_dbg_info_src->ip_to_debug_info_src = g_hash_table_new_full(
267 g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
268 (GDestroyNotify) debug_info_source_destroy);
269 if (!proc_dbg_info_src->ip_to_debug_info_src) {
270 goto error;
271 }
272
273 end:
274 return proc_dbg_info_src;
275
276 error:
277 proc_debug_info_sources_destroy(proc_dbg_info_src);
278 return NULL;
279 }
280
281 static
282 struct proc_debug_info_sources *proc_debug_info_sources_ht_get_entry(
283 GHashTable *ht, int64_t vpid)
284 {
285 gpointer key = g_new0(int64_t, 1);
286 struct proc_debug_info_sources *proc_dbg_info_src = NULL;
287
288 if (!key) {
289 goto end;
290 }
291
292 *((int64_t *) key) = vpid;
293
294 /* Exists? Return it */
295 proc_dbg_info_src = g_hash_table_lookup(ht, key);
296 if (proc_dbg_info_src) {
297 goto end;
298 }
299
300 /* Otherwise, create and return it */
301 proc_dbg_info_src = proc_debug_info_sources_create();
302 if (!proc_dbg_info_src) {
303 goto end;
304 }
305
306 g_hash_table_insert(ht, key, proc_dbg_info_src);
307 /* Ownership passed to ht */
308 key = NULL;
309 end:
310 g_free(key);
311 return proc_dbg_info_src;
312 }
313
314 static inline
315 const bt_field *event_borrow_payload_field(const bt_event *event,
316 const char *field_name)
317 {
318 const bt_field *event_payload, *field;
319
320 event_payload = bt_event_borrow_payload_field_const(event);
321 BT_ASSERT_DBG(event_payload);
322
323 field = bt_field_structure_borrow_member_field_by_name_const(
324 event_payload, field_name);
325 return field;
326 }
327
328 static inline
329 const bt_field *event_borrow_common_context_field(const bt_event *event,
330 const char *field_name)
331 {
332 const bt_field *event_common_ctx, *field = NULL;
333
334 event_common_ctx = bt_event_borrow_common_context_field_const(event);
335 if (!event_common_ctx) {
336 goto end;
337 }
338
339 field = bt_field_structure_borrow_member_field_by_name_const(
340 event_common_ctx, field_name);
341
342 end:
343 return field;
344 }
345
346 static inline
347 void event_get_common_context_signed_integer_field_value(
348 const bt_event *event, const char *field_name, int64_t *value)
349 {
350 *value = bt_field_integer_signed_get_value(
351 event_borrow_common_context_field(event, field_name));
352 }
353
354 static inline
355 void event_get_payload_build_id_length(const bt_event *event,
356 const char *field_name, uint64_t *build_id_len)
357 {
358 const bt_field *build_id_field;
359 const bt_field_class *build_id_field_class;
360
361 build_id_field = event_borrow_payload_field(event, field_name);
362 build_id_field_class = bt_field_borrow_class_const(build_id_field);
363
364 BT_ASSERT(bt_field_class_get_type(build_id_field_class) ==
365 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
366 bt_field_class_get_type(build_id_field_class) ==
367 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
368 BT_ASSERT(bt_field_class_get_type(
369 bt_field_class_array_borrow_element_field_class_const(
370 build_id_field_class)) ==
371 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
372
373 *build_id_len = bt_field_array_get_length(build_id_field);
374 }
375
376 static inline
377 void event_get_payload_build_id_value(const bt_event *event,
378 const char *field_name, uint8_t *build_id)
379 {
380 const bt_field *curr_field, *build_id_field;
381 const bt_field_class *build_id_field_class;
382 uint64_t i, build_id_len;
383
384 build_id_field = event_borrow_payload_field(event, field_name);
385 build_id_field_class = bt_field_borrow_class_const(build_id_field);
386
387 BT_ASSERT(bt_field_class_get_type(build_id_field_class) ==
388 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
389 bt_field_class_get_type(build_id_field_class) ==
390 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
391 BT_ASSERT(bt_field_class_get_type(
392 bt_field_class_array_borrow_element_field_class_const(
393 build_id_field_class)) ==
394 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
395
396 build_id_len = bt_field_array_get_length(build_id_field);
397
398 for (i = 0; i < build_id_len; i++) {
399 curr_field = bt_field_array_borrow_element_field_by_index_const(
400 build_id_field, i);
401
402 build_id[i] = bt_field_integer_unsigned_get_value(curr_field);
403 }
404 }
405
406 static
407 void event_get_payload_unsigned_integer_field_value(const bt_event *event,
408 const char *field_name, uint64_t *value)
409 {
410 *value = bt_field_integer_unsigned_get_value(
411 event_borrow_payload_field(event, field_name));
412 }
413
414 static
415 void event_get_payload_string_field_value(const bt_event *event,
416 const char *field_name, const char **value)
417 {
418 *value = bt_field_string_get_value(
419 event_borrow_payload_field(event, field_name));
420 }
421
422 static inline
423 bool event_has_payload_field(const bt_event *event,
424 const char *field_name)
425 {
426 return event_borrow_payload_field(event, field_name);
427 }
428
429 static
430 struct debug_info_source *proc_debug_info_sources_get_entry(
431 struct debug_info *debug_info,
432 struct proc_debug_info_sources *proc_dbg_info_src, uint64_t ip)
433 {
434 struct debug_info_source *debug_info_src = NULL;
435 gpointer key = g_new0(uint64_t, 1);
436 GHashTableIter iter;
437 gpointer baddr, value;
438
439 if (!key) {
440 goto end;
441 }
442
443 *((uint64_t *) key) = ip;
444
445 /* Look in IP to debug infos hash table first. */
446 debug_info_src = g_hash_table_lookup(
447 proc_dbg_info_src->ip_to_debug_info_src, key);
448 if (debug_info_src) {
449 goto end;
450 }
451
452 /* Check in all bin_infos. */
453 g_hash_table_iter_init(&iter, proc_dbg_info_src->baddr_to_bin_info);
454
455 while (g_hash_table_iter_next(&iter, &baddr, &value))
456 {
457 struct bin_info *bin = value;
458
459 if (!bin_info_has_address(value, ip)) {
460 continue;
461 }
462
463 /*
464 * Found; add it to cache.
465 *
466 * FIXME: this should be bounded in size (and implement
467 * a caching policy), and entries should be prunned when
468 * libraries are unmapped.
469 */
470 debug_info_src = debug_info_source_create_from_bin(bin, ip,
471 debug_info->self_comp);
472 if (debug_info_src) {
473 g_hash_table_insert(
474 proc_dbg_info_src->ip_to_debug_info_src, key,
475 debug_info_src);
476 /* Ownership passed to ht. */
477 key = NULL;
478 }
479 break;
480 }
481
482 end:
483 free(key);
484 return debug_info_src;
485 }
486
487 static
488 struct debug_info_source *debug_info_query(struct debug_info *debug_info,
489 int64_t vpid, uint64_t ip)
490 {
491 struct debug_info_source *dbg_info_src = NULL;
492 struct proc_debug_info_sources *proc_dbg_info_src;
493
494 proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
495 debug_info->vpid_to_proc_dbg_info_src, vpid);
496 if (!proc_dbg_info_src) {
497 goto end;
498 }
499
500 dbg_info_src = proc_debug_info_sources_get_entry(debug_info,
501 proc_dbg_info_src, ip);
502
503 end:
504 return dbg_info_src;
505 }
506
507 static
508 struct debug_info *debug_info_create(struct debug_info_component *comp,
509 const bt_trace *trace, struct bt_fd_cache *fdc)
510 {
511 int ret;
512 struct debug_info *debug_info;
513
514 BT_ASSERT(comp);
515 BT_ASSERT(trace);
516 BT_ASSERT(fdc);
517
518 debug_info = g_new0(struct debug_info, 1);
519 if (!debug_info) {
520 goto end;
521 }
522
523 debug_info->log_level = comp->log_level;
524 debug_info->self_comp = comp->self_comp;
525 debug_info->vpid_to_proc_dbg_info_src = g_hash_table_new_full(
526 g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
527 (GDestroyNotify) proc_debug_info_sources_destroy);
528 if (!debug_info->vpid_to_proc_dbg_info_src) {
529 goto error;
530 }
531
532 debug_info->comp = comp;
533 ret = debug_info_init(debug_info);
534 if (ret) {
535 goto error;
536 }
537
538 debug_info->input_trace = trace;
539 debug_info->fd_cache = fdc;
540
541 end:
542 return debug_info;
543 error:
544 g_free(debug_info);
545 return NULL;
546 }
547
548 static
549 void debug_info_destroy(struct debug_info *debug_info)
550 {
551 bt_logging_level log_level;
552 bt_self_component *self_comp;
553 bt_trace_remove_listener_status remove_listener_status;
554 if (!debug_info) {
555 goto end;
556 }
557
558 log_level = debug_info->log_level;
559 self_comp = debug_info->self_comp;
560
561 if (debug_info->vpid_to_proc_dbg_info_src) {
562 g_hash_table_destroy(debug_info->vpid_to_proc_dbg_info_src);
563 }
564
565 remove_listener_status = bt_trace_remove_destruction_listener(
566 debug_info->input_trace,
567 debug_info->destruction_listener_id);
568 if (remove_listener_status != BT_TRACE_REMOVE_LISTENER_STATUS_OK) {
569 BT_COMP_LOGE("Trace destruction listener removal failed.");
570 bt_current_thread_clear_error();
571 }
572
573 g_free(debug_info);
574 end:
575 return;
576 }
577
578 static
579 void handle_event_statedump_build_id(struct debug_info *debug_info,
580 const bt_event *event)
581 {
582 struct proc_debug_info_sources *proc_dbg_info_src;
583 uint64_t build_id_len, baddr;
584 uint8_t *build_id = NULL;
585 struct bin_info *bin;
586 int64_t vpid;
587 int ret = 0;
588
589 event_get_common_context_signed_integer_field_value(event,
590 VPID_FIELD_NAME, &vpid);
591 event_get_payload_unsigned_integer_field_value(event,
592 BADDR_FIELD_NAME, &baddr);
593
594 proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
595 debug_info->vpid_to_proc_dbg_info_src, vpid);
596 if (!proc_dbg_info_src) {
597 goto end;
598 }
599
600 bin = g_hash_table_lookup(proc_dbg_info_src->baddr_to_bin_info,
601 (gpointer) &baddr);
602 if (!bin) {
603 /*
604 * The build_id event comes after the bin has been
605 * created. If it isn't found, just ignore this event.
606 */
607 goto end;
608 }
609
610 event_get_payload_build_id_length(event, BUILD_ID_FIELD_NAME,
611 &build_id_len);
612
613 build_id = g_new0(uint8_t, build_id_len);
614 if (!build_id) {
615 goto end;
616 }
617
618 event_get_payload_build_id_value(event, BUILD_ID_FIELD_NAME, build_id);
619
620 ret = bin_info_set_build_id(bin, build_id, build_id_len);
621 if (ret) {
622 goto end;
623 }
624
625 /*
626 * Reset the is_elf_only flag in case it had been set
627 * previously, because we might find separate debug info using
628 * the new build id information.
629 */
630 bin->is_elf_only = false;
631
632 end:
633 g_free(build_id);
634 return;
635 }
636
637 static
638 void handle_event_statedump_debug_link(struct debug_info *debug_info,
639 const bt_event *event)
640 {
641 struct proc_debug_info_sources *proc_dbg_info_src;
642 struct bin_info *bin = NULL;
643 int64_t vpid;
644 uint64_t baddr;
645 const char *filename = NULL;
646 uint32_t crc32;
647 uint64_t crc_field_value;
648
649 event_get_common_context_signed_integer_field_value(event,
650 VPID_FIELD_NAME, &vpid);
651
652 event_get_payload_unsigned_integer_field_value(event,
653 BADDR_FIELD_NAME, &baddr);
654
655 event_get_payload_unsigned_integer_field_value(event,
656 CRC32_FIELD_NAME, &crc_field_value);
657
658 crc32 = (uint32_t) crc_field_value;
659
660 event_get_payload_string_field_value(event,
661 FILENAME_FIELD_NAME, &filename);
662
663 proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
664 debug_info->vpid_to_proc_dbg_info_src, vpid);
665 if (!proc_dbg_info_src) {
666 goto end;
667 }
668
669 bin = g_hash_table_lookup(proc_dbg_info_src->baddr_to_bin_info,
670 (gpointer) &baddr);
671 if (!bin) {
672 /*
673 * The debug_link event comes after the bin has been
674 * created. If it isn't found, just ignore this event.
675 */
676 goto end;
677 }
678
679 bin_info_set_debug_link(bin, filename, crc32);
680
681 end:
682 return;
683 }
684
685 static
686 void handle_bin_info_event(struct debug_info *debug_info,
687 const bt_event *event, bool has_pic_field)
688 {
689 struct proc_debug_info_sources *proc_dbg_info_src;
690 struct bin_info *bin;
691 uint64_t baddr, memsz;
692 int64_t vpid;
693 const char *path;
694 gpointer key = NULL;
695 bool is_pic;
696
697 event_get_payload_unsigned_integer_field_value(event,
698 MEMSZ_FIELD_NAME, &memsz);
699 if (memsz == 0) {
700 /* Ignore VDSO. */
701 goto end;
702 }
703
704 event_get_payload_unsigned_integer_field_value(event,
705 BADDR_FIELD_NAME, &baddr);
706
707 /*
708 * This field is not produced by the dlopen event emitted before
709 * lttng-ust 2.9.
710 */
711 if (!event_has_payload_field(event, PATH_FIELD_NAME)) {
712 goto end;
713 }
714 event_get_payload_string_field_value(event, PATH_FIELD_NAME, &path);
715
716 if (has_pic_field) {
717 uint64_t is_pic_field_value;
718
719 event_get_payload_unsigned_integer_field_value(event,
720 IS_PIC_FIELD_NAME, &is_pic_field_value);
721 is_pic = is_pic_field_value == 1;
722 } else {
723 /*
724 * dlopen has no is_pic field, because the shared
725 * object is always PIC.
726 */
727 is_pic = true;
728 }
729
730 event_get_common_context_signed_integer_field_value(event,
731 VPID_FIELD_NAME, &vpid);
732
733 proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
734 debug_info->vpid_to_proc_dbg_info_src, vpid);
735 if (!proc_dbg_info_src) {
736 goto end;
737 }
738
739 key = g_new0(uint64_t, 1);
740 if (!key) {
741 goto end;
742 }
743
744 *((uint64_t *) key) = baddr;
745
746 bin = g_hash_table_lookup(proc_dbg_info_src->baddr_to_bin_info, key);
747 if (bin) {
748 goto end;
749 }
750
751 bin = bin_info_create(debug_info->fd_cache, path, baddr, memsz, is_pic,
752 debug_info->comp->arg_debug_dir,
753 debug_info->comp->arg_target_prefix,
754 debug_info->log_level, debug_info->self_comp);
755 if (!bin) {
756 goto end;
757 }
758
759 g_hash_table_insert(proc_dbg_info_src->baddr_to_bin_info, key, bin);
760 /* Ownership passed to ht. */
761 key = NULL;
762
763 end:
764 g_free(key);
765 return;
766 }
767
768 static inline
769 void handle_event_statedump_bin_info(struct debug_info *debug_info,
770 const bt_event *event)
771 {
772 handle_bin_info_event(debug_info, event, true);
773 }
774
775 static inline
776 void handle_event_lib_load(struct debug_info *debug_info,
777 const bt_event *event)
778 {
779 handle_bin_info_event(debug_info, event, false);
780 }
781
782 static
783 void handle_event_lib_unload(struct debug_info *debug_info,
784 const bt_event *event)
785 {
786 gboolean ret;
787 struct proc_debug_info_sources *proc_dbg_info_src;
788 uint64_t baddr;
789 int64_t vpid;
790
791 event_get_payload_unsigned_integer_field_value(event, BADDR_FIELD_NAME,
792 &baddr);
793
794 event_get_common_context_signed_integer_field_value(event,
795 VPID_FIELD_NAME, &vpid);
796
797 proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
798 debug_info->vpid_to_proc_dbg_info_src, vpid);
799 if (!proc_dbg_info_src) {
800 /*
801 * It's an unload event for a library for which no load event
802 * was previously received.
803 */
804 goto end;
805 }
806
807 ret = g_hash_table_remove(proc_dbg_info_src->baddr_to_bin_info,
808 (gpointer) &baddr);
809 BT_ASSERT(ret);
810 end:
811 return;
812 }
813
814 static
815 void handle_event_statedump_start(struct debug_info *debug_info,
816 const bt_event *event)
817 {
818 struct proc_debug_info_sources *proc_dbg_info_src;
819 int64_t vpid;
820
821 event_get_common_context_signed_integer_field_value(
822 event, VPID_FIELD_NAME, &vpid);
823
824 proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
825 debug_info->vpid_to_proc_dbg_info_src, vpid);
826 if (!proc_dbg_info_src) {
827 goto end;
828 }
829
830 g_hash_table_remove_all(proc_dbg_info_src->baddr_to_bin_info);
831 g_hash_table_remove_all(proc_dbg_info_src->ip_to_debug_info_src);
832
833 end:
834 return;
835 }
836
837 static
838 void trace_debug_info_remove_func(const bt_trace *in_trace, void *data)
839 {
840 struct debug_info_msg_iter *debug_it = data;
841 if (debug_it->debug_info_map) {
842 gboolean ret;
843 ret = g_hash_table_remove(debug_it->debug_info_map,
844 (gpointer) in_trace);
845 BT_ASSERT(ret);
846 }
847 }
848
849 static
850 void handle_event_statedump(struct debug_info_msg_iter *debug_it,
851 const bt_event *event)
852 {
853 const bt_event_class *event_class;
854 const char *event_name;
855 GQuark q_event_name;
856 const bt_trace *trace;
857 struct debug_info *debug_info;
858
859 BT_ASSERT(debug_it);
860 BT_ASSERT(event);
861
862 event_class = bt_event_borrow_class_const(event);
863
864 event_name = bt_event_class_get_name(event_class);
865
866 trace = bt_stream_borrow_trace_const(
867 bt_event_borrow_stream_const(event));
868
869 debug_info = g_hash_table_lookup(debug_it->debug_info_map, trace);
870 if (!debug_info) {
871 bt_trace_add_listener_status add_listener_status;
872
873 debug_info = debug_info_create(debug_it->debug_info_component,
874 trace, &debug_it->fd_cache);
875 g_hash_table_insert(debug_it->debug_info_map, (gpointer) trace,
876 debug_info);
877 add_listener_status = bt_trace_add_destruction_listener(
878 trace, trace_debug_info_remove_func, debug_it,
879 &debug_info->destruction_listener_id);
880 BT_ASSERT(add_listener_status == BT_TRACE_ADD_LISTENER_STATUS_OK);
881 }
882
883 q_event_name = g_quark_try_string(event_name);
884
885 if (q_event_name == debug_info->q_statedump_bin_info) {
886 /* State dump */
887 handle_event_statedump_bin_info(debug_info, event);
888 } else if (q_event_name == debug_info->q_dl_open ||
889 q_event_name == debug_info->q_lib_load) {
890 /*
891 * dl_open and lib_load events are both checked for since
892 * only dl_open was produced as of lttng-ust 2.8.
893 *
894 * lib_load, which is produced from lttng-ust 2.9+, is a lot
895 * more reliable since it will be emitted when other functions
896 * of the dlopen family are called (e.g. dlmopen) and when
897 * library are transitively loaded.
898 */
899 handle_event_lib_load(debug_info, event);
900 } else if (q_event_name == debug_info->q_statedump_start) {
901 /* Start state dump */
902 handle_event_statedump_start(debug_info, event);
903 } else if (q_event_name == debug_info->q_statedump_debug_link) {
904 /* Debug link info */
905 handle_event_statedump_debug_link(debug_info, event);
906 } else if (q_event_name == debug_info->q_statedump_build_id) {
907 /* Build ID info */
908 handle_event_statedump_build_id(debug_info, event);
909 } else if (q_event_name == debug_info->q_lib_unload) {
910 handle_event_lib_unload(debug_info, event);
911 }
912
913 return;
914 }
915
916 static
917 void destroy_debug_info_comp(struct debug_info_component *debug_info)
918 {
919 if (!debug_info) {
920 return;
921 }
922
923 g_free(debug_info->arg_debug_dir);
924 g_free(debug_info->arg_debug_info_field_name);
925 g_free(debug_info->arg_target_prefix);
926 g_free(debug_info);
927 }
928
929 static
930 void fill_debug_info_bin_field(struct debug_info_source *dbg_info_src,
931 bool full_path, bt_field *curr_field,
932 bt_logging_level log_level, bt_self_component *self_comp)
933 {
934 bt_field_string_set_value_status set_status;
935 bt_field_string_append_status append_status;
936
937 BT_ASSERT_DBG(bt_field_get_class_type(curr_field) ==
938 BT_FIELD_CLASS_TYPE_STRING);
939
940 if (dbg_info_src) {
941 if (full_path) {
942 set_status = bt_field_string_set_value(curr_field,
943 dbg_info_src->bin_path);
944 } else {
945 set_status = bt_field_string_set_value(curr_field,
946 dbg_info_src->short_bin_path);
947 }
948 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
949 BT_COMP_LOGE("Cannot set path component of `bin` "
950 "curr_field field's value: str-fc-addr=%p",
951 curr_field);
952 bt_current_thread_clear_error();
953 }
954
955 append_status = bt_field_string_append(curr_field,
956 dbg_info_src->bin_loc);
957 if (append_status != BT_FIELD_STRING_APPEND_STATUS_OK) {
958 BT_COMP_LOGE("Cannot set bin location component of `bin` "
959 "curr_field field's value: str-fc-addr=%p",
960 curr_field);
961 bt_current_thread_clear_error();
962 }
963 } else {
964 set_status = bt_field_string_set_value(curr_field, "");
965 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
966 BT_COMP_LOGE("Cannot set `bin` curr_field field's value: "
967 "str-fc-addr=%p", curr_field);
968 bt_current_thread_clear_error();
969 }
970 }
971 }
972
973 static
974 void fill_debug_info_func_field(struct debug_info_source *dbg_info_src,
975 bt_field *curr_field, bt_logging_level log_level,
976 bt_self_component *self_comp)
977 {
978 bt_field_string_set_value_status status;
979
980 BT_ASSERT_DBG(bt_field_get_class_type(curr_field) ==
981 BT_FIELD_CLASS_TYPE_STRING);
982 if (dbg_info_src && dbg_info_src->func) {
983 status = bt_field_string_set_value(curr_field,
984 dbg_info_src->func);
985 } else {
986 status = bt_field_string_set_value(curr_field, "");
987 }
988 if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
989 BT_COMP_LOGE("Cannot set `func` curr_field field's value: "
990 "str-fc-addr=%p", curr_field);
991 bt_current_thread_clear_error();
992 }
993 }
994
995 static
996 void fill_debug_info_src_field(struct debug_info_source *dbg_info_src,
997 bool full_path, bt_field *curr_field,
998 bt_logging_level log_level,
999 bt_self_component *self_comp)
1000 {
1001 bt_field_string_set_value_status set_status;
1002 bt_field_string_append_status append_status;
1003
1004 BT_ASSERT_DBG(bt_field_get_class_type(curr_field) ==
1005 BT_FIELD_CLASS_TYPE_STRING);
1006
1007 if (dbg_info_src && dbg_info_src->src_path) {
1008 if (full_path) {
1009 set_status = bt_field_string_set_value(curr_field,
1010 dbg_info_src->src_path);
1011 } else {
1012 set_status = bt_field_string_set_value(curr_field,
1013 dbg_info_src->short_src_path);
1014 }
1015 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1016 BT_COMP_LOGE("Cannot set path component of `src` "
1017 "curr_field field's value: str-fc-addr=%p",
1018 curr_field);
1019 bt_current_thread_clear_error();
1020 }
1021
1022 append_status = bt_field_string_append(curr_field, ":");
1023 if (append_status != BT_FIELD_STRING_APPEND_STATUS_OK) {
1024 BT_COMP_LOGE("Cannot set colon component of `src` "
1025 "curr_field field's value: str-fc-addr=%p",
1026 curr_field);
1027 bt_current_thread_clear_error();
1028 }
1029
1030 append_status = bt_field_string_append(curr_field,
1031 dbg_info_src->line_no);
1032 if (append_status != BT_FIELD_STRING_APPEND_STATUS_OK) {
1033 BT_COMP_LOGE("Cannot set line number component of `src` "
1034 "curr_field field's value: str-fc-addr=%p",
1035 curr_field);
1036 bt_current_thread_clear_error();
1037 }
1038 } else {
1039 set_status = bt_field_string_set_value(curr_field, "");
1040 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1041 BT_COMP_LOGE("Cannot set `src` curr_field field's value: "
1042 "str-fc-addr=%p", curr_field);
1043 bt_current_thread_clear_error();
1044 }
1045 }
1046 }
1047
1048 static
1049 void fill_debug_info_field_empty(bt_field *debug_info_field,
1050 bt_logging_level log_level, bt_self_component *self_comp)
1051 {
1052 bt_field_string_set_value_status status;
1053 bt_field *bin_field, *func_field, *src_field;
1054
1055 BT_ASSERT_DBG(bt_field_get_class_type(debug_info_field) ==
1056 BT_FIELD_CLASS_TYPE_STRUCTURE);
1057
1058 bin_field = bt_field_structure_borrow_member_field_by_name(
1059 debug_info_field, "bin");
1060 func_field = bt_field_structure_borrow_member_field_by_name(
1061 debug_info_field, "func");
1062 src_field = bt_field_structure_borrow_member_field_by_name(
1063 debug_info_field, "src");
1064
1065 BT_ASSERT_DBG(bt_field_get_class_type(bin_field) ==
1066 BT_FIELD_CLASS_TYPE_STRING);
1067 BT_ASSERT_DBG(bt_field_get_class_type(func_field) ==
1068 BT_FIELD_CLASS_TYPE_STRING);
1069 BT_ASSERT_DBG(bt_field_get_class_type(src_field) ==
1070 BT_FIELD_CLASS_TYPE_STRING);
1071
1072 status = bt_field_string_set_value(bin_field, "");
1073 if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1074 BT_COMP_LOGE("Cannot set `bin` field's value: "
1075 "str-fc-addr=%p", bin_field);
1076 bt_current_thread_clear_error();
1077 }
1078
1079 status = bt_field_string_set_value(func_field, "");
1080 if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1081 BT_COMP_LOGE("Cannot set `func` field's value: "
1082 "str-fc-addr=%p", func_field);
1083 bt_current_thread_clear_error();
1084 }
1085
1086 status = bt_field_string_set_value(src_field, "");
1087 if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1088 BT_COMP_LOGE("Cannot set `src` field's value: "
1089 "str-fc-addr=%p", src_field);
1090 bt_current_thread_clear_error();
1091 }
1092 }
1093 static
1094 void fill_debug_info_field(struct debug_info *debug_info, int64_t vpid,
1095 uint64_t ip, bt_field *debug_info_field)
1096 {
1097 struct debug_info_source *dbg_info_src;
1098 const bt_field_class *debug_info_fc;
1099
1100 BT_ASSERT_DBG(bt_field_get_class_type(debug_info_field) ==
1101 BT_FIELD_CLASS_TYPE_STRUCTURE);
1102
1103 debug_info_fc = bt_field_borrow_class_const(debug_info_field);
1104
1105 BT_ASSERT_DBG(bt_field_class_structure_get_member_count(
1106 debug_info_fc) == 3);
1107
1108 dbg_info_src = debug_info_query(debug_info, vpid, ip);
1109
1110 fill_debug_info_bin_field(dbg_info_src,
1111 debug_info->comp->arg_full_path,
1112 bt_field_structure_borrow_member_field_by_name(
1113 debug_info_field, "bin"),
1114 debug_info->log_level, debug_info->self_comp);
1115 fill_debug_info_func_field(dbg_info_src,
1116 bt_field_structure_borrow_member_field_by_name(
1117 debug_info_field, "func"),
1118 debug_info->log_level, debug_info->self_comp);
1119 fill_debug_info_src_field(dbg_info_src,
1120 debug_info->comp->arg_full_path,
1121 bt_field_structure_borrow_member_field_by_name(
1122 debug_info_field, "src"),
1123 debug_info->log_level, debug_info->self_comp);
1124 }
1125
1126 static
1127 void fill_debug_info_event_if_needed(struct debug_info_msg_iter *debug_it,
1128 const bt_event *in_event, bt_event *out_event)
1129 {
1130 bt_field *out_common_ctx_field, *out_debug_info_field;
1131 const bt_field *vpid_field, *ip_field, *in_common_ctx_field;
1132 const bt_field_class *in_common_ctx_fc;
1133 struct debug_info *debug_info;
1134 uint64_t vpid;
1135 int64_t ip;
1136 gchar *debug_info_field_name =
1137 debug_it->debug_info_component->arg_debug_info_field_name;
1138 bt_logging_level log_level = debug_it->log_level;
1139 bt_self_component *self_comp = debug_it->self_comp;
1140
1141 in_common_ctx_field = bt_event_borrow_common_context_field_const(
1142 in_event);
1143 if (!in_common_ctx_field) {
1144 /*
1145 * There is no event common context so no need to add debug
1146 * info field.
1147 */
1148 goto end;
1149 }
1150
1151 in_common_ctx_fc = bt_field_borrow_class_const(in_common_ctx_field);
1152 if (!is_event_common_ctx_dbg_info_compatible(in_common_ctx_fc,
1153 debug_it->ir_maps->debug_info_field_class_name)) {
1154 /*
1155 * The input event common context does not have the necessary
1156 * fields to resolve debug information.
1157 */
1158 goto end;
1159 }
1160
1161 /* Borrow the debug-info field. */
1162 out_common_ctx_field = bt_event_borrow_common_context_field(out_event);
1163 if (!out_common_ctx_field) {
1164 goto end;
1165 }
1166
1167 out_debug_info_field = bt_field_structure_borrow_member_field_by_name(
1168 out_common_ctx_field, debug_info_field_name);
1169
1170 vpid_field = bt_field_structure_borrow_member_field_by_name_const(
1171 out_common_ctx_field, VPID_FIELD_NAME);
1172 ip_field = bt_field_structure_borrow_member_field_by_name_const(
1173 out_common_ctx_field, IP_FIELD_NAME);
1174
1175 vpid = bt_field_integer_signed_get_value(vpid_field);
1176 ip = bt_field_integer_unsigned_get_value(ip_field);
1177
1178 /*
1179 * Borrow the debug_info structure needed for the source
1180 * resolving.
1181 */
1182 debug_info = g_hash_table_lookup(debug_it->debug_info_map,
1183 bt_stream_borrow_trace_const(
1184 bt_event_borrow_stream_const(in_event)));
1185
1186 if (debug_info) {
1187 /*
1188 * Perform the debug-info resolving and set the event fields
1189 * accordingly.
1190 */
1191 fill_debug_info_field(debug_info, vpid, ip, out_debug_info_field);
1192 } else {
1193 BT_COMP_LOGD("No debug information for this trace. Setting debug "
1194 "info fields to empty strings.");
1195 fill_debug_info_field_empty(out_debug_info_field,
1196 log_level, self_comp);
1197 }
1198 end:
1199 return;
1200 }
1201
1202 static
1203 void update_event_statedump_if_needed(struct debug_info_msg_iter *debug_it,
1204 const bt_event *in_event)
1205 {
1206 const bt_field *event_common_ctx;
1207 const bt_field_class *event_common_ctx_fc;
1208 const bt_event_class *in_event_class = bt_event_borrow_class_const(in_event);
1209
1210 /*
1211 * If the event is an lttng_ust_statedump event AND has the right event
1212 * common context fields update the debug-info view for this process.
1213 */
1214 event_common_ctx = bt_event_borrow_common_context_field_const(in_event);
1215 if (!event_common_ctx) {
1216 goto end;
1217 }
1218
1219 event_common_ctx_fc = bt_field_borrow_class_const(event_common_ctx);
1220 if (is_event_common_ctx_dbg_info_compatible(event_common_ctx_fc,
1221 debug_it->ir_maps->debug_info_field_class_name)) {
1222 /* Checkout if it might be a one of lttng ust statedump events. */
1223 const char *in_event_name = bt_event_class_get_name(in_event_class);
1224 if (strncmp(in_event_name, LTTNG_UST_STATEDUMP_PREFIX,
1225 strlen(LTTNG_UST_STATEDUMP_PREFIX)) == 0) {
1226 /* Handle statedump events. */
1227 handle_event_statedump(debug_it, in_event);
1228 }
1229 }
1230 end:
1231 return;
1232 }
1233
1234 static
1235 bt_message *handle_event_message(struct debug_info_msg_iter *debug_it,
1236 const bt_message *in_message)
1237 {
1238 const bt_clock_snapshot *cs;
1239 const bt_clock_class *default_cc;
1240 const bt_packet *in_packet;
1241 const bt_stream *in_stream;
1242 const bt_stream *out_stream;
1243 bt_event_class *out_event_class;
1244 bt_packet *out_packet = NULL;
1245 bt_event *out_event;
1246 bt_logging_level log_level = debug_it->log_level;
1247 bt_self_component *self_comp = debug_it->self_comp;
1248
1249 bt_message *out_message = NULL;
1250
1251 /* Borrow the input event and its event class. */
1252 const bt_event *in_event =
1253 bt_message_event_borrow_event_const(in_message);
1254 const bt_event_class *in_event_class =
1255 bt_event_borrow_class_const(in_event);
1256
1257 update_event_statedump_if_needed(debug_it, in_event);
1258
1259 out_event_class = trace_ir_mapping_borrow_mapped_event_class(
1260 debug_it->ir_maps, in_event_class);
1261 if (!out_event_class) {
1262 out_event_class = trace_ir_mapping_create_new_mapped_event_class(
1263 debug_it->ir_maps, in_event_class);
1264 }
1265 BT_ASSERT_DBG(out_event_class);
1266
1267 /* Borrow the input stream. */
1268 in_stream = bt_event_borrow_stream_const(in_event);
1269 BT_ASSERT_DBG(in_stream);
1270 out_stream = trace_ir_mapping_borrow_mapped_stream(debug_it->ir_maps,
1271 in_stream);
1272 BT_ASSERT_DBG(in_stream);
1273
1274 /* Borrow the input and output packets. */
1275 in_packet = bt_event_borrow_packet_const(in_event);
1276 if (in_packet) {
1277 out_packet = trace_ir_mapping_borrow_mapped_packet(
1278 debug_it->ir_maps, in_packet);
1279 }
1280
1281 default_cc = bt_stream_class_borrow_default_clock_class_const(
1282 bt_event_class_borrow_stream_class_const(in_event_class));
1283 if (default_cc) {
1284 /* Borrow event clock snapshot. */
1285 cs = bt_message_event_borrow_default_clock_snapshot_const(
1286 in_message);
1287
1288 /* Create an output event message. */
1289 if (out_packet) {
1290 out_message =
1291 bt_message_event_create_with_packet_and_default_clock_snapshot(
1292 debug_it->input_iterator,
1293 out_event_class, out_packet,
1294 bt_clock_snapshot_get_value(cs));
1295 } else {
1296 out_message =
1297 bt_message_event_create_with_default_clock_snapshot(
1298 debug_it->input_iterator,
1299 out_event_class, out_stream,
1300 bt_clock_snapshot_get_value(cs));
1301 }
1302 } else {
1303 if (out_packet) {
1304 out_message = bt_message_event_create_with_packet(
1305 debug_it->input_iterator, out_event_class,
1306 out_packet);
1307 } else {
1308 out_message = bt_message_event_create(
1309 debug_it->input_iterator, out_event_class,
1310 out_stream);
1311 }
1312 }
1313
1314 if (!out_message) {
1315 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1316 "Error creating output event message.");
1317 goto error;
1318 }
1319
1320 out_event = bt_message_event_borrow_event(out_message);
1321
1322 /* Copy the original fields to the output event. */
1323 if (copy_event_content(in_event, out_event, log_level, self_comp) !=
1324 DEBUG_INFO_TRACE_IR_MAPPING_STATUS_OK) {
1325 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1326 "Error copying event message content output event message: "
1327 "in-ev-addr=%p, out-ev-addr=%p", in_event, out_event);
1328 goto error;
1329 }
1330
1331 /*
1332 * Try to set the debug-info fields based on debug information that is
1333 * gathered so far.
1334 */
1335 fill_debug_info_event_if_needed(debug_it, in_event, out_event);
1336
1337 goto end;
1338
1339 error:
1340 BT_MESSAGE_PUT_REF_AND_RESET(out_message);
1341 end:
1342 return out_message;
1343 }
1344
1345 static
1346 bt_message *handle_stream_begin_message(struct debug_info_msg_iter *debug_it,
1347 const bt_message *in_message)
1348 {
1349 const bt_stream *in_stream;
1350 bt_message *out_message;
1351 bt_stream *out_stream;
1352 bt_logging_level log_level = debug_it->log_level;
1353 bt_self_component *self_comp = debug_it->self_comp;
1354
1355 in_stream = bt_message_stream_beginning_borrow_stream_const(in_message);
1356 BT_ASSERT(in_stream);
1357
1358 /* Create a duplicated output stream. */
1359 out_stream = trace_ir_mapping_create_new_mapped_stream(
1360 debug_it->ir_maps, in_stream);
1361 if (!out_stream) {
1362 out_message = NULL;
1363 goto error;
1364 }
1365
1366 /* Create an output stream beginning message. */
1367 out_message = bt_message_stream_beginning_create(
1368 debug_it->input_iterator, out_stream);
1369 if (!out_message) {
1370 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1371 "Error creating output stream beginning message: "
1372 "out-s-addr=%p", out_stream);
1373 }
1374 error:
1375 return out_message;
1376 }
1377
1378 static
1379 bt_message *handle_stream_end_message(struct debug_info_msg_iter *debug_it,
1380 const bt_message *in_message)
1381 {
1382 const bt_stream *in_stream;
1383 bt_message *out_message = NULL;
1384 bt_stream *out_stream;
1385 bt_logging_level log_level = debug_it->log_level;
1386 bt_self_component *self_comp = debug_it->self_comp;
1387
1388 in_stream = bt_message_stream_end_borrow_stream_const(in_message);
1389 BT_ASSERT(in_stream);
1390
1391 out_stream = trace_ir_mapping_borrow_mapped_stream(
1392 debug_it->ir_maps, in_stream);
1393 BT_ASSERT(out_stream);
1394
1395 /* Create an output stream end message. */
1396 out_message = bt_message_stream_end_create(debug_it->input_iterator,
1397 out_stream);
1398 if (!out_message) {
1399 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1400 "Error creating output stream end message: "
1401 "out-s-addr=%p", out_stream);
1402 goto end;
1403 }
1404
1405 /* Remove stream from trace mapping hashtable. */
1406 trace_ir_mapping_remove_mapped_stream(debug_it->ir_maps, in_stream);
1407
1408 end:
1409 return out_message;
1410 }
1411
1412 static
1413 bt_message *handle_packet_begin_message(struct debug_info_msg_iter *debug_it,
1414 const bt_message *in_message)
1415 {
1416 bool has_default_clock_snapshot;
1417 const bt_clock_snapshot *cs;
1418 bt_message *out_message = NULL;
1419 bt_packet *out_packet;
1420 bt_logging_level log_level = debug_it->log_level;
1421 bt_self_component *self_comp = debug_it->self_comp;
1422
1423 const bt_packet *in_packet =
1424 bt_message_packet_beginning_borrow_packet_const(in_message);
1425 BT_ASSERT(in_packet);
1426
1427 /* This packet should not be already mapped. */
1428 BT_ASSERT(!trace_ir_mapping_borrow_mapped_packet(
1429 debug_it->ir_maps, in_packet));
1430
1431 out_packet = trace_ir_mapping_create_new_mapped_packet(debug_it->ir_maps,
1432 in_packet);
1433
1434 BT_ASSERT(out_packet);
1435
1436 has_default_clock_snapshot =
1437 bt_stream_class_packets_have_beginning_default_clock_snapshot(
1438 bt_stream_borrow_class_const(
1439 bt_packet_borrow_stream_const(in_packet)));
1440 if (has_default_clock_snapshot) {
1441 /* Borrow clock snapshot. */
1442 cs = bt_message_packet_beginning_borrow_default_clock_snapshot_const(
1443 in_message);
1444
1445 /* Create an output packet beginning message. */
1446 out_message = bt_message_packet_beginning_create_with_default_clock_snapshot(
1447 debug_it->input_iterator, out_packet,
1448 bt_clock_snapshot_get_value(cs));
1449 } else {
1450 out_message = bt_message_packet_beginning_create(
1451 debug_it->input_iterator, out_packet);
1452 }
1453 if (!out_message) {
1454 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1455 "Error creating output packet beginning message: "
1456 "out-p-addr=%p", out_packet);
1457 }
1458
1459 return out_message;
1460 }
1461
1462 static
1463 bt_message *handle_packet_end_message(struct debug_info_msg_iter *debug_it,
1464 const bt_message *in_message)
1465 {
1466 bool has_default_clock_snapshot;
1467 const bt_clock_snapshot *cs;
1468 const bt_packet *in_packet;
1469 bt_message *out_message = NULL;
1470 bt_packet *out_packet;
1471 bt_logging_level log_level = debug_it->log_level;
1472 bt_self_component *self_comp = debug_it->self_comp;
1473
1474 in_packet = bt_message_packet_end_borrow_packet_const(in_message);
1475 BT_ASSERT(in_packet);
1476
1477 out_packet = trace_ir_mapping_borrow_mapped_packet(debug_it->ir_maps, in_packet);
1478 BT_ASSERT(out_packet);
1479
1480 has_default_clock_snapshot =
1481 bt_stream_class_packets_have_end_default_clock_snapshot(
1482 bt_stream_borrow_class_const(
1483 bt_packet_borrow_stream_const(in_packet)));
1484 if (has_default_clock_snapshot) {
1485 /* Borrow clock snapshot. */
1486 cs = bt_message_packet_end_borrow_default_clock_snapshot_const(
1487 in_message);
1488
1489 /* Create an outpute packet end message. */
1490 out_message = bt_message_packet_end_create_with_default_clock_snapshot(
1491 debug_it->input_iterator, out_packet,
1492 bt_clock_snapshot_get_value(cs));
1493 } else {
1494 out_message = bt_message_packet_end_create(
1495 debug_it->input_iterator, out_packet);
1496 }
1497
1498 if (!out_message) {
1499 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1500 "Error creating output packet end message: "
1501 "out-p-addr=%p", out_packet);
1502 goto end;
1503 }
1504
1505 /* Remove packet from data mapping hashtable. */
1506 trace_ir_mapping_remove_mapped_packet(debug_it->ir_maps, in_packet);
1507
1508 end:
1509 return out_message;
1510 }
1511
1512 static
1513 bt_message *handle_msg_iterator_inactivity(
1514 struct debug_info_msg_iter *debug_it __attribute__((unused)),
1515 const bt_message *in_message)
1516 {
1517 /*
1518 * This message type can be forwarded directly because it does
1519 * not refer to any objects in the trace class.
1520 */
1521 bt_message_get_ref(in_message);
1522 return (bt_message*) in_message;
1523 }
1524
1525 static
1526 bt_message *handle_discarded_events_message(struct debug_info_msg_iter *debug_it,
1527 const bt_message *in_message)
1528 {
1529 const bt_clock_snapshot *begin_cs, *end_cs;
1530 const bt_stream *in_stream;
1531 bool has_default_clock_snapshots;
1532 uint64_t discarded_events, begin_cs_value, end_cs_value;
1533 bt_property_availability prop_avail;
1534 bt_message *out_message = NULL;
1535 bt_stream *out_stream;
1536 bt_logging_level log_level = debug_it->log_level;
1537 bt_self_component *self_comp = debug_it->self_comp;
1538
1539 in_stream = bt_message_discarded_events_borrow_stream_const(
1540 in_message);
1541 BT_ASSERT(in_stream);
1542
1543 out_stream = trace_ir_mapping_borrow_mapped_stream( debug_it->ir_maps,
1544 in_stream);
1545 BT_ASSERT(out_stream);
1546
1547 has_default_clock_snapshots =
1548 bt_stream_class_discarded_events_have_default_clock_snapshots(
1549 bt_stream_borrow_class_const(in_stream));
1550 if (has_default_clock_snapshots) {
1551 begin_cs = bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
1552 in_message);
1553 end_cs = bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
1554 in_message);
1555
1556 begin_cs_value = bt_clock_snapshot_get_value(begin_cs);
1557 end_cs_value = bt_clock_snapshot_get_value(end_cs);
1558
1559 out_message = bt_message_discarded_events_create_with_default_clock_snapshots(
1560 debug_it->input_iterator, out_stream,
1561 begin_cs_value, end_cs_value);
1562 } else {
1563 out_message = bt_message_discarded_events_create(
1564 debug_it->input_iterator, out_stream);
1565 }
1566 if (!out_message) {
1567 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1568 "Error creating output discarded events message: "
1569 "out-s-addr=%p", out_stream);
1570 goto error;
1571 }
1572
1573 prop_avail = bt_message_discarded_events_get_count(in_message,
1574 &discarded_events);
1575
1576 if (prop_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1577 bt_message_discarded_events_set_count(out_message,
1578 discarded_events);
1579 }
1580
1581 error:
1582 return out_message;
1583 }
1584
1585 static
1586 bt_message *handle_discarded_packets_message(struct debug_info_msg_iter *debug_it,
1587 const bt_message *in_message)
1588 {
1589 const bt_clock_snapshot *begin_cs, *end_cs;
1590 bool has_default_clock_snapshots;
1591 const bt_stream *in_stream;
1592 uint64_t discarded_packets, begin_cs_value, end_cs_value;
1593 bt_property_availability prop_avail;
1594 bt_message *out_message = NULL;
1595 bt_stream *out_stream;
1596 bt_logging_level log_level = debug_it->log_level;
1597 bt_self_component *self_comp = debug_it->self_comp;
1598
1599 in_stream = bt_message_discarded_packets_borrow_stream_const(
1600 in_message);
1601 BT_ASSERT(in_stream);
1602
1603 out_stream = trace_ir_mapping_borrow_mapped_stream( debug_it->ir_maps,
1604 in_stream);
1605 BT_ASSERT(out_stream);
1606
1607 has_default_clock_snapshots =
1608 bt_stream_class_discarded_packets_have_default_clock_snapshots(
1609 bt_stream_borrow_class_const(in_stream));
1610 if (has_default_clock_snapshots) {
1611 begin_cs = bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
1612 in_message);
1613
1614 end_cs = bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
1615 in_message);
1616
1617 begin_cs_value = bt_clock_snapshot_get_value(begin_cs);
1618 end_cs_value = bt_clock_snapshot_get_value(end_cs);
1619
1620 out_message = bt_message_discarded_packets_create_with_default_clock_snapshots(
1621 debug_it->input_iterator, out_stream,
1622 begin_cs_value, end_cs_value);
1623 } else {
1624 out_message = bt_message_discarded_packets_create(
1625 debug_it->input_iterator, out_stream);
1626 }
1627 if (!out_message) {
1628 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1629 "Error creating output discarded packet message: "
1630 "out-s-addr=%p", out_stream);
1631 goto error;
1632 }
1633
1634 prop_avail = bt_message_discarded_packets_get_count(in_message,
1635 &discarded_packets);
1636 if (prop_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1637 bt_message_discarded_packets_set_count(out_message,
1638 discarded_packets);
1639 }
1640
1641 error:
1642 return out_message;
1643 }
1644
1645 static
1646 const bt_message *handle_message(struct debug_info_msg_iter *debug_it,
1647 const bt_message *in_message)
1648 {
1649 bt_message *out_message = NULL;
1650
1651 switch (bt_message_get_type(in_message)) {
1652 case BT_MESSAGE_TYPE_EVENT:
1653 out_message = handle_event_message(debug_it, in_message);
1654 break;
1655 case BT_MESSAGE_TYPE_PACKET_BEGINNING:
1656 out_message = handle_packet_begin_message(debug_it, in_message);
1657 break;
1658 case BT_MESSAGE_TYPE_PACKET_END:
1659 out_message = handle_packet_end_message(debug_it, in_message);
1660 break;
1661 case BT_MESSAGE_TYPE_STREAM_BEGINNING:
1662 out_message = handle_stream_begin_message(debug_it, in_message);
1663 break;
1664 case BT_MESSAGE_TYPE_STREAM_END:
1665 out_message = handle_stream_end_message(debug_it, in_message);
1666 break;
1667 case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY:
1668 out_message = handle_msg_iterator_inactivity(debug_it, in_message);
1669 break;
1670 case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
1671 out_message = handle_discarded_events_message(debug_it, in_message);
1672 break;
1673 case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
1674 out_message = handle_discarded_packets_message(debug_it, in_message);
1675 break;
1676 default:
1677 bt_common_abort();
1678 break;
1679 }
1680
1681 return out_message;
1682 }
1683
1684 static
1685 struct bt_param_validation_map_value_entry_descr debug_info_params[] = {
1686 { "debug-info-field-name", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
1687 { "debug-info-dir", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
1688 { "target-prefix", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
1689 { "full-path", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
1690 BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
1691 };
1692
1693 static
1694 bt_component_class_initialize_method_status init_from_params(
1695 struct debug_info_component *debug_info_component,
1696 const bt_value *params)
1697 {
1698 const bt_value *value;
1699 bt_component_class_initialize_method_status status;
1700 bt_logging_level log_level = debug_info_component->log_level;
1701 enum bt_param_validation_status validation_status;
1702 gchar *validate_error = NULL;
1703
1704 validation_status = bt_param_validation_validate(params,
1705 debug_info_params, &validate_error);
1706 if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
1707 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
1708 goto end;
1709 } else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
1710 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
1711 BT_COMP_LOGE_APPEND_CAUSE(debug_info_component->self_comp,
1712 "%s", validate_error);
1713 goto end;
1714 }
1715
1716 BT_ASSERT(params);
1717
1718 value = bt_value_map_borrow_entry_value_const(params,
1719 "debug-info-field-name");
1720 if (value) {
1721 debug_info_component->arg_debug_info_field_name =
1722 g_strdup(bt_value_string_get(value));
1723 } else {
1724 debug_info_component->arg_debug_info_field_name =
1725 g_strdup(DEFAULT_DEBUG_INFO_FIELD_NAME);
1726 }
1727
1728 value = bt_value_map_borrow_entry_value_const(params, "debug-info-dir");
1729 if (value) {
1730 debug_info_component->arg_debug_dir =
1731 g_strdup(bt_value_string_get(value));
1732 } else {
1733 debug_info_component->arg_debug_dir = NULL;
1734 }
1735
1736
1737 value = bt_value_map_borrow_entry_value_const(params, "target-prefix");
1738 if (value) {
1739 debug_info_component->arg_target_prefix =
1740 g_strdup(bt_value_string_get(value));
1741 } else {
1742 debug_info_component->arg_target_prefix = NULL;
1743 }
1744
1745 value = bt_value_map_borrow_entry_value_const(params, "full-path");
1746 if (value) {
1747 debug_info_component->arg_full_path = bt_value_bool_get(value);
1748 } else {
1749 debug_info_component->arg_full_path = BT_FALSE;
1750 }
1751
1752 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
1753
1754 end:
1755 g_free(validate_error);
1756
1757 return status;
1758 }
1759
1760 bt_component_class_initialize_method_status debug_info_comp_init(
1761 bt_self_component_filter *self_comp_flt,
1762 bt_self_component_filter_configuration *config __attribute__((unused)),
1763 const bt_value *params, void *init_method_data __attribute__((unused)))
1764 {
1765 struct debug_info_component *debug_info_comp;
1766 bt_component_class_initialize_method_status status =
1767 BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
1768 bt_self_component_add_port_status add_port_status;
1769 bt_self_component *self_comp =
1770 bt_self_component_filter_as_self_component(self_comp_flt);
1771 bt_logging_level log_level = bt_component_get_logging_level(
1772 bt_self_component_as_component(self_comp));
1773
1774 BT_COMP_LOGI("Initializing debug_info component: "
1775 "comp-addr=%p, params-addr=%p", self_comp, params);
1776
1777 debug_info_comp = g_new0(struct debug_info_component, 1);
1778 if (!debug_info_comp) {
1779 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1780 "Failed to allocate one debug_info component.");
1781 goto error;
1782 }
1783
1784 debug_info_comp->log_level = log_level;
1785 debug_info_comp->self_comp = self_comp;
1786 debug_info_comp->self_comp_filter = self_comp_flt;
1787 bt_self_component_set_data(self_comp, debug_info_comp);
1788
1789 add_port_status = bt_self_component_filter_add_input_port(
1790 self_comp_flt, "in", NULL, NULL);
1791 if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
1792 status = (int) add_port_status;
1793 goto error;
1794 }
1795
1796 add_port_status = bt_self_component_filter_add_output_port(
1797 self_comp_flt, "out", NULL, NULL);
1798 if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
1799 status = (int) add_port_status;
1800 goto error;
1801 }
1802
1803 status = init_from_params(debug_info_comp, params);
1804 if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
1805 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1806 "Cannot configure debug_info component: "
1807 "debug_info-comp-addr=%p, params-addr=%p",
1808 debug_info_comp, params);
1809 goto error;
1810 }
1811
1812 goto end;
1813
1814 error:
1815 destroy_debug_info_comp(debug_info_comp);
1816 bt_self_component_set_data(self_comp, NULL);
1817
1818 if (status == BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
1819 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
1820 }
1821 end:
1822 return status;
1823 }
1824
1825 void debug_info_comp_finalize(bt_self_component_filter *self_comp_flt)
1826 {
1827 struct debug_info_component *debug_info =
1828 bt_self_component_get_data(
1829 bt_self_component_filter_as_self_component(
1830 self_comp_flt));
1831 bt_logging_level log_level = debug_info->log_level;
1832 bt_self_component *self_comp = debug_info->self_comp;
1833
1834 BT_COMP_LOGI("Finalizing debug_info self_component: comp-addr=%p",
1835 self_comp);
1836
1837 destroy_debug_info_comp(debug_info);
1838 }
1839
1840 bt_message_iterator_class_next_method_status debug_info_msg_iter_next(
1841 bt_self_message_iterator *self_msg_iter,
1842 const bt_message_array_const msgs, uint64_t capacity,
1843 uint64_t *count)
1844 {
1845 bt_message_iterator *upstream_iterator = NULL;
1846 bt_message_iterator_next_status upstream_iterator_ret_status;
1847 struct debug_info_msg_iter *debug_info_msg_iter;
1848 struct debug_info_component *debug_info = NULL;
1849 bt_message_iterator_class_next_method_status status;
1850 bt_self_component *self_comp = NULL;
1851 bt_message_array_const input_msgs;
1852 const bt_message *out_message;
1853 uint64_t curr_msg_idx, i;
1854
1855 status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
1856
1857 self_comp = bt_self_message_iterator_borrow_component(self_msg_iter);
1858 BT_ASSERT_DBG(self_comp);
1859
1860 debug_info = bt_self_component_get_data(self_comp);
1861 BT_ASSERT_DBG(debug_info);
1862
1863 debug_info_msg_iter = bt_self_message_iterator_get_data(self_msg_iter);
1864 BT_ASSERT_DBG(debug_info_msg_iter);
1865
1866 upstream_iterator = debug_info_msg_iter->msg_iter;
1867 BT_ASSERT_DBG(upstream_iterator);
1868
1869 upstream_iterator_ret_status =
1870 bt_message_iterator_next(
1871 upstream_iterator, &input_msgs, count);
1872 if (upstream_iterator_ret_status !=
1873 BT_MESSAGE_ITERATOR_NEXT_STATUS_OK) {
1874 /*
1875 * No messages were returned. Not necessarily an error.
1876 * Convert the upstream message iterator status to a
1877 * self status.
1878 */
1879 status = (int) upstream_iterator_ret_status;
1880 goto end;
1881 }
1882
1883 /*
1884 * There should never be more received messages than the capacity we
1885 * provided.
1886 */
1887 BT_ASSERT_DBG(*count <= capacity);
1888
1889 for (curr_msg_idx = 0; curr_msg_idx < *count; curr_msg_idx++) {
1890 out_message = handle_message(debug_info_msg_iter,
1891 input_msgs[curr_msg_idx]);
1892 if (!out_message) {
1893 goto handle_msg_error;
1894 }
1895
1896 msgs[curr_msg_idx] = out_message;
1897 /*
1898 * Drop our reference of the input message as we are done with
1899 * it and created a output copy.
1900 */
1901 bt_message_put_ref(input_msgs[curr_msg_idx]);
1902 }
1903
1904 goto end;
1905
1906 handle_msg_error:
1907 /*
1908 * Drop references of all the output messages created before the
1909 * failure.
1910 */
1911 for (i = 0; i < curr_msg_idx; i++) {
1912 bt_message_put_ref(msgs[i]);
1913 }
1914
1915 /*
1916 * Drop references of all the input messages not dropped before the
1917 * failure.
1918 */
1919 for (i = curr_msg_idx; i < *count; i++) {
1920 bt_message_put_ref(input_msgs[i]);
1921 }
1922
1923 status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
1924
1925 end:
1926 return status;
1927 }
1928
1929 static
1930 void debug_info_msg_iter_destroy(struct debug_info_msg_iter *debug_info_msg_iter)
1931 {
1932 if (!debug_info_msg_iter) {
1933 goto end;
1934 }
1935
1936 if (debug_info_msg_iter->msg_iter) {
1937 bt_message_iterator_put_ref(
1938 debug_info_msg_iter->msg_iter);
1939 }
1940
1941 if (debug_info_msg_iter->ir_maps) {
1942 trace_ir_maps_destroy(debug_info_msg_iter->ir_maps);
1943 }
1944
1945 if (debug_info_msg_iter->debug_info_map) {
1946 g_hash_table_destroy(debug_info_msg_iter->debug_info_map);
1947 }
1948
1949 bt_fd_cache_fini(&debug_info_msg_iter->fd_cache);
1950 g_free(debug_info_msg_iter);
1951
1952 end:
1953 return;
1954 }
1955
1956 bt_message_iterator_class_initialize_method_status debug_info_msg_iter_init(
1957 bt_self_message_iterator *self_msg_iter,
1958 bt_self_message_iterator_configuration *config,
1959 bt_self_component_port_output *self_port __attribute__((unused)))
1960 {
1961 bt_message_iterator_class_initialize_method_status status;
1962 bt_message_iterator_create_from_message_iterator_status
1963 msg_iter_status;
1964 struct bt_self_component_port_input *input_port = NULL;
1965 bt_message_iterator *upstream_iterator = NULL;
1966 struct debug_info_msg_iter *debug_info_msg_iter = NULL;
1967 gchar *debug_info_field_name;
1968 int ret;
1969 bt_self_component *self_comp =
1970 bt_self_message_iterator_borrow_component(self_msg_iter);
1971 bt_logging_level log_level = bt_component_get_logging_level(
1972 bt_self_component_as_component(self_comp));
1973
1974 debug_info_msg_iter = g_new0(struct debug_info_msg_iter, 1);
1975 if (!debug_info_msg_iter) {
1976 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
1977 goto error;
1978 }
1979
1980 debug_info_msg_iter->log_level = log_level;
1981 debug_info_msg_iter->self_comp = self_comp;
1982
1983 debug_info_msg_iter->debug_info_component =
1984 bt_self_component_get_data(self_comp);
1985
1986 /* Borrow the upstream input port. */
1987 input_port = bt_self_component_filter_borrow_input_port_by_name(
1988 debug_info_msg_iter->debug_info_component->self_comp_filter,
1989 "in");
1990 if (!input_port) {
1991 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
1992 goto error;
1993 }
1994
1995 /* Create an iterator on the upstream component. */
1996 msg_iter_status = bt_message_iterator_create_from_message_iterator(
1997 self_msg_iter, input_port, &upstream_iterator);
1998 if (msg_iter_status != BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_OK) {
1999 status = (int) msg_iter_status;
2000 goto error;
2001 }
2002
2003 BT_MESSAGE_ITERATOR_MOVE_REF(
2004 debug_info_msg_iter->msg_iter, upstream_iterator);
2005
2006 /* Create hashtable that will contain debug info mapping. */
2007 debug_info_msg_iter->debug_info_map = g_hash_table_new_full(
2008 g_direct_hash, g_direct_equal, (GDestroyNotify) NULL,
2009 (GDestroyNotify) debug_info_destroy);
2010 if (!debug_info_msg_iter->debug_info_map) {
2011 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2012 goto error;
2013 }
2014
2015 debug_info_field_name =
2016 debug_info_msg_iter->debug_info_component->arg_debug_info_field_name;
2017
2018 debug_info_msg_iter->ir_maps = trace_ir_maps_create(self_comp,
2019 debug_info_field_name, log_level);
2020 if (!debug_info_msg_iter->ir_maps) {
2021 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2022 goto error;
2023 }
2024
2025 ret = bt_fd_cache_init(&debug_info_msg_iter->fd_cache, log_level);
2026 if (ret) {
2027 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2028 goto error;
2029 }
2030
2031 bt_self_message_iterator_configuration_set_can_seek_forward(config,
2032 bt_message_iterator_can_seek_forward(
2033 debug_info_msg_iter->msg_iter));
2034
2035 bt_self_message_iterator_set_data(self_msg_iter, debug_info_msg_iter);
2036 debug_info_msg_iter->input_iterator = self_msg_iter;
2037
2038 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
2039 goto end;
2040
2041 error:
2042 debug_info_msg_iter_destroy(debug_info_msg_iter);
2043
2044 end:
2045 return status;
2046 }
2047
2048 bt_message_iterator_class_can_seek_beginning_method_status
2049 debug_info_msg_iter_can_seek_beginning(bt_self_message_iterator *self_msg_iter,
2050 bt_bool *can_seek)
2051 {
2052 struct debug_info_msg_iter *debug_info_msg_iter =
2053 bt_self_message_iterator_get_data(self_msg_iter);
2054 BT_ASSERT(debug_info_msg_iter);
2055
2056 return (int) bt_message_iterator_can_seek_beginning(
2057 debug_info_msg_iter->msg_iter, can_seek);
2058 }
2059
2060 bt_message_iterator_class_seek_beginning_method_status
2061 debug_info_msg_iter_seek_beginning(bt_self_message_iterator *self_msg_iter)
2062 {
2063 struct debug_info_msg_iter *debug_info_msg_iter =
2064 bt_self_message_iterator_get_data(self_msg_iter);
2065 bt_message_iterator_class_seek_beginning_method_status status =
2066 BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_OK;
2067 bt_message_iterator_seek_beginning_status seek_beg_status;
2068
2069 BT_ASSERT(debug_info_msg_iter);
2070
2071 /* Ask the upstream component to seek to the beginning. */
2072 seek_beg_status = bt_message_iterator_seek_beginning(
2073 debug_info_msg_iter->msg_iter);
2074 if (seek_beg_status != BT_MESSAGE_ITERATOR_SEEK_BEGINNING_STATUS_OK) {
2075 status = (int) seek_beg_status;
2076 goto end;
2077 }
2078
2079 /* Clear this iterator data. */
2080 trace_ir_maps_clear(debug_info_msg_iter->ir_maps);
2081 g_hash_table_remove_all(debug_info_msg_iter->debug_info_map);
2082
2083 end:
2084 return status;
2085 }
2086
2087 void debug_info_msg_iter_finalize(bt_self_message_iterator *it)
2088 {
2089 struct debug_info_msg_iter *debug_info_msg_iter;
2090
2091 debug_info_msg_iter = bt_self_message_iterator_get_data(it);
2092 BT_ASSERT(debug_info_msg_iter);
2093
2094 debug_info_msg_iter_destroy(debug_info_msg_iter);
2095 }
This page took 0.075947 seconds and 4 git commands to generate.