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