lib/debuginfo.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  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27
  28 #include <assert.h>
  29 #include <glib.h>
  30 #include <babeltrace/types.h>
  31 #include <babeltrace/ctf-ir/metadata.h>
  32 #include <babeltrace/debuginfo.h>
  33 #include <babeltrace/so-info.h>
  34 #include <babeltrace/babeltrace-internal.h>
  35
  36 struct proc_debug_info_sources {
  37         /*
  38          * Hash table: base address (pointer to uint64_t) to so info; owned by
  39          * proc_debug_info_sources.
  40          */
  41         GHashTable *baddr_to_so_info;
  42
  43         /*
  44          * Hash table: IP (pointer to uint64_t) to (struct debug_info_source *);
  45          * owned by proc_debug_info_sources.
  46          */
  47         GHashTable *ip_to_debug_info_src;
  48 };
  49
  50 struct debug_info {
  51         /*
  52          * Hash table of VPIDs (pointer to int64_t) to
  53          * (struct ctf_proc_debug_infos*); owned by debug_info.
  54          */
  55         GHashTable *vpid_to_proc_dbg_info_src;
  56         GQuark q_statedump_soinfo;
  57         GQuark q_statedump_debug_link;
  58         GQuark q_statedump_build_id;
  59         GQuark q_statedump_start;
  60         GQuark q_dl_open;
  61 };
  62
  63 static
  64 int debug_info_init(struct debug_info *info)
  65 {
  66         info->q_statedump_soinfo = g_quark_from_string(
  67                         "lttng_ust_statedump:soinfo");
  68         info->q_statedump_debug_link = g_quark_from_string(
  69                         "lttng_ust_statedump:debug_link)");
  70         info->q_statedump_build_id = g_quark_from_string(
  71                         "lttng_ust_statedump:build_id");
  72         info->q_statedump_start = g_quark_from_string(
  73                         "lttng_ust_statedump:start");
  74         info->q_dl_open = g_quark_from_string("lttng_ust_dl:dlopen");
  75
  76         return so_info_init();
  77 }
  78
  79 static
  80 void debug_info_source_destroy(struct debug_info_source *debug_info_src)
  81 {
  82         if (!debug_info_src) {
  83                 return;
  84         }
  85
  86         free(debug_info_src->func);
  87         free(debug_info_src->src_path);
  88         free(debug_info_src->bin_path);
  89         g_free(debug_info_src);
  90 }
  91
  92 /*
  93  * Returns the location of a path's file (the last element of the path).
  94  * Returns the original path on error.
  95  */
  96 static
  97 const char *get_filename_from_path(const char *path)
  98 {
  99         size_t i = strlen(path);
 100
 101         if (i == 0) {
 102                 goto end;
 103         }
 104
 105         if (path[i - 1] == '/') {
 106                 /*
 107                  * Path ends with a trailing slash, no filename to return.
 108                  * Return the original path.
 109                  */
 110                 goto end;
 111         }
 112
 113         while (i-- > 0) {
 114                 if (path[i] == '/') {
 115                         path = &path[i + 1];
 116                         goto end;
 117                 }
 118         }
 119 end:
 120         return path;
 121 }
 122
 123 static
 124 struct debug_info_source *debug_info_source_create_from_so(struct so_info *so,
 125                 uint64_t ip)
 126 {
 127         int ret;
 128         struct debug_info_source *debug_info_src = NULL;
 129         struct source_location *src_loc = NULL;
 130
 131         debug_info_src = g_new0(struct debug_info_source, 1);
 132
 133         if (!debug_info_src) {
 134                 goto end;
 135         }
 136
 137         /* Lookup function name */
 138         ret = so_info_lookup_function_name(so, ip, &debug_info_src->func);
 139         if (ret) {
 140                 goto error;
 141         }
 142
 143         /* Can't retrieve src_loc from ELF only, skip it */
 144         if (so->is_elf_only) {
 145                 goto end;
 146         }
 147
 148         /* Lookup source location */
 149         ret = so_info_lookup_source_location(so, ip, &src_loc);
 150         if (ret) {
 151                 goto error;
 152         }
 153
 154         if (src_loc) {
 155                 debug_info_src->line_no = src_loc->line_no;
 156
 157                 if (src_loc->filename) {
 158                         debug_info_src->src_path = strdup(src_loc->filename);
 159                         if (!debug_info_src->src_path) {
 160                                 goto error;
 161                         }
 162
 163                         debug_info_src->short_src_path = get_filename_from_path(
 164                                         src_loc->filename);
 165
 166                 }
 167
 168                 source_location_destroy(src_loc);
 169         }
 170
 171         if (so->elf_path) {
 172                 debug_info_src->bin_path = strdup(so->elf_path);
 173                 if (!debug_info_src->bin_path) {
 174                         goto error;
 175                 }
 176
 177                 debug_info_src->short_bin_path = get_filename_from_path(
 178                                 debug_info_src->bin_path);
 179         }
 180
 181 end:
 182         return debug_info_src;
 183
 184 error:
 185         debug_info_source_destroy(debug_info_src);
 186         return NULL;
 187 }
 188
 189 static
 190 void proc_debug_info_sources_destroy(
 191                 struct proc_debug_info_sources *proc_dbg_info_src)
 192 {
 193         if (!proc_dbg_info_src) {
 194                 return;
 195         }
 196
 197         if (proc_dbg_info_src->baddr_to_so_info) {
 198                 g_hash_table_destroy(proc_dbg_info_src->baddr_to_so_info);
 199         }
 200
 201         if (proc_dbg_info_src->ip_to_debug_info_src) {
 202                 g_hash_table_destroy(proc_dbg_info_src->ip_to_debug_info_src);
 203         }
 204
 205         g_free(proc_dbg_info_src);
 206 }
 207
 208 static
 209 struct proc_debug_info_sources *proc_debug_info_sources_create(void)
 210 {
 211         struct proc_debug_info_sources *proc_dbg_info_src = NULL;
 212
 213         proc_dbg_info_src = g_new0(struct proc_debug_info_sources, 1);
 214         if (!proc_dbg_info_src) {
 215                 goto end;
 216         }
 217
 218         proc_dbg_info_src->baddr_to_so_info = g_hash_table_new_full(
 219                         g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
 220                         (GDestroyNotify) so_info_destroy);
 221         if (!proc_dbg_info_src->baddr_to_so_info) {
 222                 goto error;
 223         }
 224
 225         proc_dbg_info_src->ip_to_debug_info_src = g_hash_table_new_full(
 226                         g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
 227                         (GDestroyNotify) debug_info_source_destroy);
 228         if (!proc_dbg_info_src->ip_to_debug_info_src) {
 229                 goto error;
 230         }
 231
 232 end:
 233         return proc_dbg_info_src;
 234
 235 error:
 236         proc_debug_info_sources_destroy(proc_dbg_info_src);
 237         return NULL;
 238 }
 239
 240 static
 241 struct proc_debug_info_sources *proc_debug_info_sources_ht_get_entry(
 242                 GHashTable *ht, int64_t vpid)
 243 {
 244         gpointer key = g_new0(int64_t, 1);
 245         struct proc_debug_info_sources *proc_dbg_info_src = NULL;
 246
 247         if (!key) {
 248                 goto end;
 249         }
 250
 251         *((int64_t *) key) = vpid;
 252
 253         /* Exists? Return it */
 254         proc_dbg_info_src = g_hash_table_lookup(ht, key);
 255         if (proc_dbg_info_src) {
 256                 goto end;
 257         }
 258
 259         /* Otherwise, create and return it */
 260         proc_dbg_info_src = proc_debug_info_sources_create();
 261         if (!proc_dbg_info_src) {
 262                 goto end;
 263         }
 264
 265         g_hash_table_insert(ht, key, proc_dbg_info_src);
 266         /* Ownership passed to ht */
 267         key = NULL;
 268 end:
 269         g_free(key);
 270         return proc_dbg_info_src;
 271 }
 272
 273 static
 274 struct debug_info_source *proc_debug_info_sources_get_entry(
 275                 struct proc_debug_info_sources *proc_dbg_info_src, uint64_t ip)
 276 {
 277         struct debug_info_source *debug_info_src = NULL;
 278         gpointer key = g_new0(uint64_t, 1);
 279         GHashTableIter iter;
 280         gpointer baddr, value;
 281
 282         if (!key) {
 283                 goto end;
 284         }
 285
 286         *((uint64_t *) key) = ip;
 287
 288         /* Look in IP to debug infos hash table first. */
 289         debug_info_src = g_hash_table_lookup(
 290                         proc_dbg_info_src->ip_to_debug_info_src,
 291                         key);
 292         if (debug_info_src) {
 293                 goto end;
 294         }
 295
 296         /* Check in all so_infos. */
 297         g_hash_table_iter_init(&iter, proc_dbg_info_src->baddr_to_so_info);
 298
 299         while (g_hash_table_iter_next(&iter, &baddr, &value))
 300         {
 301                 struct so_info *so = value;
 302
 303                 if (!so_info_has_address(value, ip)) {
 304                         continue;
 305                 }
 306
 307                 /*
 308                  * Found; add it to cache.
 309                  *
 310                  * FIXME: this should be bounded in size (and implement
 311                  * a caching policy), and entries should be prunned when
 312                  * libraries are unmapped.
 313                  */
 314                 debug_info_src = debug_info_source_create_from_so(so, ip);
 315                 if (debug_info_src) {
 316                         g_hash_table_insert(
 317                                         proc_dbg_info_src->ip_to_debug_info_src,
 318                                         key, debug_info_src);
 319                         /* Ownership passed to ht. */
 320                         key = NULL;
 321                 }
 322                 break;
 323         }
 324
 325 end:
 326         free(key);
 327         return debug_info_src;
 328 }
 329
 330 BT_HIDDEN
 331 struct debug_info_source *debug_info_query(struct debug_info *debug_info,
 332                 int64_t vpid, uint64_t ip)
 333 {
 334         struct debug_info_source *dbg_info_src = NULL;
 335         struct proc_debug_info_sources *proc_dbg_info_src;
 336
 337         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 338                         debug_info->vpid_to_proc_dbg_info_src, vpid);
 339         if (!proc_dbg_info_src) {
 340                 goto end;
 341         }
 342
 343         dbg_info_src = proc_debug_info_sources_get_entry(
 344                         proc_dbg_info_src, ip);
 345         if (!dbg_info_src) {
 346                 goto end;
 347         }
 348
 349 end:
 350         return dbg_info_src;
 351 }
 352
 353 BT_HIDDEN
 354 struct debug_info *debug_info_create(void)
 355 {
 356         int ret;
 357         struct debug_info *debug_info;
 358
 359         debug_info = g_new0(struct debug_info, 1);
 360         if (!debug_info) {
 361                 goto end;
 362         }
 363
 364         debug_info->vpid_to_proc_dbg_info_src = g_hash_table_new_full(
 365                         g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
 366                         (GDestroyNotify) proc_debug_info_sources_destroy);
 367         if (!debug_info->vpid_to_proc_dbg_info_src) {
 368                 goto error;
 369         }
 370
 371         ret = debug_info_init(debug_info);
 372         if (ret) {
 373                 goto error;
 374         }
 375
 376 end:
 377         return debug_info;
 378 error:
 379         g_free(debug_info);
 380         return NULL;
 381 }
 382
 383 BT_HIDDEN
 384 void debug_info_destroy(struct debug_info *debug_info)
 385 {
 386         if (!debug_info) {
 387                 goto end;
 388         }
 389
 390         if (debug_info->vpid_to_proc_dbg_info_src) {
 391                 g_hash_table_destroy(debug_info->vpid_to_proc_dbg_info_src);
 392         }
 393
 394         g_free(debug_info);
 395 end:
 396         return;
 397 }
 398
 399 static
 400 void handle_statedump_build_id_event(struct debug_info *debug_info,
 401                 struct ctf_event_definition *event_def)
 402 {
 403         struct proc_debug_info_sources *proc_dbg_info_src;
 404         struct bt_definition *event_fields_def = NULL;
 405         struct bt_definition *sec_def = NULL;
 406         struct bt_definition *baddr_def = NULL;
 407         struct bt_definition *vpid_def = NULL;
 408         struct bt_definition *build_id_def = NULL;
 409         struct definition_sequence *build_id_seq;
 410         struct so_info *so = NULL;
 411         int i;
 412         int64_t vpid;
 413         uint64_t baddr;
 414         uint8_t *build_id = NULL;
 415         uint64_t build_id_len;
 416
 417         event_fields_def = (struct bt_definition *) event_def->event_fields;
 418         sec_def = (struct bt_definition *)
 419                         event_def->stream->stream_event_context;
 420
 421         if (!event_fields_def || !sec_def) {
 422                 goto end;
 423         }
 424
 425         baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
 426         if (!baddr_def) {
 427                 goto end;
 428         }
 429
 430         vpid_def = bt_lookup_definition(sec_def, "_vpid");
 431         if (!vpid_def) {
 432                 goto end;
 433         }
 434
 435         build_id_def = bt_lookup_definition(event_fields_def, "_build_id");
 436         if (!build_id_def) {
 437                 goto end;
 438         }
 439
 440         if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
 441                 goto end;
 442         }
 443
 444         if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
 445                 goto end;
 446         }
 447
 448         if (build_id_def->declaration->id != CTF_TYPE_SEQUENCE) {
 449                 goto end;
 450         }
 451
 452         baddr = bt_get_unsigned_int(baddr_def);
 453         vpid = bt_get_signed_int(vpid_def);
 454         build_id_seq = container_of(build_id_def,
 455                         struct definition_sequence, p);
 456         build_id_len = build_id_seq->length->value._unsigned;
 457
 458         build_id = g_malloc(build_id_len);
 459         if (!build_id) {
 460                 goto end;
 461         }
 462
 463         for (i = 0; i < build_id_len; ++i) {
 464                 struct bt_definition **field;
 465
 466                 field = (struct bt_definition **) &g_ptr_array_index(
 467                                 build_id_seq->elems, i);
 468                 build_id[i] = bt_get_unsigned_int(*field);
 469         }
 470
 471         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 472                         debug_info->vpid_to_proc_dbg_info_src, vpid);
 473         if (!proc_dbg_info_src) {
 474                 goto end;
 475         }
 476
 477         so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
 478                         (gpointer) &baddr);
 479         if (!so) {
 480                 /*
 481                  * The build_id event comes after the so has been
 482                  * created. If it isn't found, just ignore this event.
 483                  */
 484                 goto end;
 485         }
 486
 487         so_info_set_build_id(so, build_id, build_id_len);
 488
 489 end:
 490         free(build_id);
 491         return;
 492 }
 493
 494 static
 495 void handle_statedump_debug_link_event(struct debug_info *debug_info,
 496                 struct ctf_event_definition *event_def)
 497 {
 498         struct proc_debug_info_sources *proc_dbg_info_src;
 499         struct bt_definition *event_fields_def = NULL;
 500         struct bt_definition *sec_def = NULL;
 501         struct bt_definition *baddr_def = NULL;
 502         struct bt_definition *vpid_def = NULL;
 503         struct bt_definition *filename_def = NULL;
 504         struct bt_definition *crc32_def = NULL;
 505         struct so_info *so = NULL;
 506         int64_t vpid;
 507         uint64_t baddr;
 508         char *filename = NULL;
 509         uint32_t crc32;
 510
 511         event_fields_def = (struct bt_definition *) event_def->event_fields;
 512         sec_def = (struct bt_definition *)
 513                         event_def->stream->stream_event_context;
 514
 515         if (!event_fields_def || !sec_def) {
 516                 goto end;
 517         }
 518
 519         baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
 520         if (!baddr_def) {
 521                 goto end;
 522         }
 523
 524         vpid_def = bt_lookup_definition(sec_def, "_vpid");
 525         if (!vpid_def) {
 526                 goto end;
 527         }
 528
 529         filename_def = bt_lookup_definition(event_fields_def, "_filename");
 530         if (!filename_def) {
 531                 goto end;
 532         }
 533
 534         crc32_def = bt_lookup_definition(event_fields_def, "_crc32");
 535         if (!crc32_def) {
 536                 goto end;
 537         }
 538
 539         if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
 540                 goto end;
 541         }
 542
 543         if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
 544                 goto end;
 545         }
 546
 547         if (filename_def->declaration->id != CTF_TYPE_STRING) {
 548                 goto end;
 549         }
 550
 551         if (crc32_def->declaration->id != CTF_TYPE_INTEGER) {
 552                 goto end;
 553         }
 554
 555         baddr = bt_get_unsigned_int(baddr_def);
 556         vpid = bt_get_signed_int(vpid_def);
 557
 558         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 559                         debug_info->vpid_to_proc_dbg_info_src, vpid);
 560         if (!proc_dbg_info_src) {
 561                 goto end;
 562         }
 563
 564         so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
 565                         (gpointer) &baddr);
 566         if (!so) {
 567                 /*
 568                  * The debug_link event comes after the so has been
 569                  * created. If it isn't found, just ignore this event.
 570                  */
 571                 goto end;
 572         }
 573
 574         filename = bt_get_string(filename_def);
 575         crc32 = bt_get_unsigned_int(crc32_def);
 576
 577         so_info_set_debug_link(so, filename, crc32);
 578
 579 end:
 580         return;
 581 }
 582
 583 static
 584 void handle_statedump_soinfo_event(struct debug_info *debug_info,
 585                 struct ctf_event_definition *event_def)
 586 {
 587         struct bt_definition *baddr_def = NULL;
 588         struct bt_definition *memsz_def = NULL;
 589         struct bt_definition *sopath_def = NULL;
 590         struct bt_definition *vpid_def = NULL;
 591         struct bt_definition *event_fields_def = NULL;
 592         struct bt_definition *sec_def = NULL;
 593         struct proc_debug_info_sources *proc_dbg_info_src;
 594         struct so_info *so;
 595         uint64_t baddr, memsz;
 596         int64_t vpid;
 597         const char *sopath;
 598         gpointer key = NULL;
 599
 600         event_fields_def = (struct bt_definition *) event_def->event_fields;
 601         sec_def = (struct bt_definition *)
 602                 event_def->stream->stream_event_context;
 603
 604         if (!event_fields_def || !sec_def) {
 605                 goto end;
 606         }
 607
 608         baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
 609         if (!baddr_def) {
 610                 goto end;
 611         }
 612
 613         memsz_def = bt_lookup_definition(event_fields_def, "_memsz");
 614         if (!memsz_def) {
 615                 goto end;
 616         }
 617
 618         sopath_def = bt_lookup_definition(event_fields_def, "_sopath");
 619         if (!sopath_def) {
 620                 goto end;
 621         }
 622
 623         vpid_def = bt_lookup_definition(sec_def, "_vpid");
 624         if (!vpid_def) {
 625                 goto end;
 626         }
 627
 628         if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
 629                 goto end;
 630         }
 631
 632         if (memsz_def->declaration->id != CTF_TYPE_INTEGER) {
 633                 goto end;
 634         }
 635
 636         if (sopath_def->declaration->id != CTF_TYPE_STRING) {
 637                 goto end;
 638         }
 639
 640         if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
 641                 goto end;
 642         }
 643
 644         baddr = bt_get_unsigned_int(baddr_def);
 645         memsz = bt_get_unsigned_int(memsz_def);
 646         sopath = bt_get_string(sopath_def);
 647         vpid = bt_get_signed_int(vpid_def);
 648
 649         if (!sopath) {
 650                 goto end;
 651         }
 652
 653         if (memsz == 0) {
 654                 /* Ignore VDSO. */
 655                 goto end;
 656         }
 657
 658         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 659                         debug_info->vpid_to_proc_dbg_info_src, vpid);
 660         if (!proc_dbg_info_src) {
 661                 goto end;
 662         }
 663
 664         key = g_new0(uint64_t, 1);
 665         if (!key) {
 666                 goto end;
 667         }
 668
 669         *((uint64_t *) key) = baddr;
 670
 671         so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
 672                         key);
 673         if (so) {
 674                 goto end;
 675         }
 676
 677         so = so_info_create(sopath, baddr, memsz);
 678         if (!so) {
 679                 goto end;
 680         }
 681
 682         g_hash_table_insert(proc_dbg_info_src->baddr_to_so_info,
 683                         key, so);
 684         /* Ownership passed to ht. */
 685         key = NULL;
 686
 687 end:
 688         g_free(key);
 689         return;
 690 }
 691
 692 static
 693 void handle_statedump_start(struct debug_info *debug_info,
 694                 struct ctf_event_definition *event_def)
 695 {
 696         struct bt_definition *vpid_def = NULL;
 697         struct bt_definition *sec_def = NULL;
 698         struct proc_debug_info_sources *proc_dbg_info_src;
 699         int64_t vpid;
 700
 701         sec_def = (struct bt_definition *)
 702                         event_def->stream->stream_event_context;
 703         if (!sec_def) {
 704                 goto end;
 705         }
 706
 707         vpid_def = bt_lookup_definition(sec_def, "_vpid");
 708         if (!vpid_def) {
 709                 goto end;
 710         }
 711
 712         vpid = bt_get_signed_int(vpid_def);
 713
 714         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 715                         debug_info->vpid_to_proc_dbg_info_src, vpid);
 716         if (!proc_dbg_info_src) {
 717                 goto end;
 718         }
 719
 720         g_hash_table_remove_all(proc_dbg_info_src->baddr_to_so_info);
 721         g_hash_table_remove_all(proc_dbg_info_src->ip_to_debug_info_src);
 722
 723 end:
 724         return;
 725 }
 726
 727 static
 728 void register_event_debug_infos(struct debug_info *debug_info,
 729                 struct ctf_event_definition *event)
 730 {
 731         struct bt_definition *ip_def, *vpid_def;
 732         int64_t vpid;
 733         uint64_t ip;
 734         struct bt_definition *sec_def;
 735
 736         /* Get stream event context definition. */
 737         sec_def = (struct bt_definition *) event->stream->stream_event_context;
 738         if (!sec_def) {
 739                 goto end;
 740         }
 741
 742         /* Get "ip" and "vpid" definitions. */
 743         vpid_def = bt_lookup_definition((struct bt_definition *) sec_def,
 744                          "_vpid");
 745         ip_def = bt_lookup_definition((struct bt_definition *) sec_def, "_ip");
 746
 747         if (!vpid_def || !ip_def) {
 748                  goto end;
 749         }
 750
 751         vpid = bt_get_signed_int(vpid_def);
 752         ip = bt_get_unsigned_int(ip_def);
 753
 754         /* Get debug info for this context. */
 755         ((struct definition_integer *) ip_def)->debug_info_src =
 756                         debug_info_query(debug_info, vpid, ip);
 757
 758 end:
 759         return;
 760 }
 761
 762 BT_HIDDEN
 763 void debug_info_handle_event(struct debug_info *debug_info,
 764                 struct ctf_event_definition *event)
 765 {
 766         struct ctf_event_declaration *event_class;
 767         struct ctf_stream_declaration *stream_class;
 768
 769         if (!debug_info || !event) {
 770                 goto end;
 771         }
 772
 773         stream_class = event->stream->stream_class;
 774         event_class = g_ptr_array_index(stream_class->events_by_id,
 775                         event->stream->event_id);
 776
 777         if (event_class->name == debug_info->q_statedump_soinfo ||
 778                         event_class->name == debug_info->q_dl_open) {
 779                 /* State dump/dlopen() */
 780                 handle_statedump_soinfo_event(debug_info, event);
 781         } else if (event_class->name == debug_info->q_statedump_start) {
 782                 /* Start state dump */
 783                 handle_statedump_start(debug_info, event);
 784         } else if (event_class->name == debug_info->q_statedump_debug_link) {
 785                 /* Debug link info */
 786                 handle_statedump_debug_link_event(debug_info, event);
 787         } else if (event_class->name == debug_info->q_statedump_build_id) {
 788                 /* Build ID info */
 789                 handle_statedump_build_id_event(debug_info, event);
 790         } else {
 791                 /* Other events: register debug infos */
 792                 register_event_debug_infos(debug_info, event);
 793         }
 794
 795 end:
 796         return;
 797 }