proc.c

   1 /*
   2  * This file is part of ltrace.
   3  * Copyright (C) 2011,2012,2013,2014 Petr Machata, Red Hat Inc.
   4  * Copyright (C) 2010 Joe Damato
   5  * Copyright (C) 1998,2009 Juan Cespedes
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <sys/types.h>
  26 #include <assert.h>
  27 #include <errno.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "backend.h"
  33 #include "breakpoint.h"
  34 #include "debug.h"
  35 #include "fetch.h"
  36 #include "options.h"
  37 #include "proc.h"
  38 #include "value_dict.h"
  39
  40 #ifndef OS_HAVE_PROCESS_DATA
  41 int
  42 os_process_init(struct process *proc)
  43 {
  44         return 0;
  45 }
  46
  47 void
  48 os_process_destroy(struct process *proc)
  49 {
  50 }
  51
  52 int
  53 os_process_clone(struct process *retp, struct process *proc)
  54 {
  55         return 0;
  56 }
  57
  58 int
  59 os_process_exec(struct process *proc)
  60 {
  61         return 0;
  62 }
  63 #endif
  64
  65 #ifndef ARCH_HAVE_PROCESS_DATA
  66 int
  67 arch_process_init(struct process *proc)
  68 {
  69         return 0;
  70 }
  71
  72 void
  73 arch_process_destroy(struct process *proc)
  74 {
  75 }
  76
  77 int
  78 arch_process_clone(struct process *retp, struct process *proc)
  79 {
  80         return 0;
  81 }
  82
  83 int
  84 arch_process_exec(struct process *proc)
  85 {
  86         return 0;
  87 }
  88 #endif
  89
  90 #ifndef ARCH_HAVE_DYNLINK_DONE
  91 void
  92 arch_dynlink_done(struct process *proc)
  93 {
  94 }
  95 #endif
  96
  97 static int add_process(struct process *proc, int was_exec);
  98 static void unlist_process(struct process *proc);
  99
 100 static void
 101 destroy_unwind(struct process *proc)
 102 {
 103 #if defined(HAVE_LIBUNWIND)
 104         if (proc->unwind_priv != NULL)
 105                 _UPT_destroy(proc->unwind_priv);
 106         if (proc->unwind_as != NULL)
 107                 unw_destroy_addr_space(proc->unwind_as);
 108 #endif /* defined(HAVE_LIBUNWIND) */
 109
 110 #if defined(HAVE_LIBDW)
 111         if (proc->dwfl != NULL)
 112                 dwfl_end(proc->dwfl);
 113 #endif /* defined(HAVE_LIBDW) */
 114 }
 115
 116 static int
 117 process_bare_init(struct process *proc, const char *filename,
 118                   pid_t pid, int was_exec)
 119 {
 120         if (!was_exec) {
 121                 memset(proc, 0, sizeof(*proc));
 122
 123                 proc->filename = strdup(filename);
 124                 if (proc->filename == NULL) {
 125                 fail:
 126                         free(proc->filename);
 127                         if (proc->breakpoints != NULL) {
 128                                 dict_destroy(proc->breakpoints,
 129                                              NULL, NULL, NULL);
 130                                 free(proc->breakpoints);
 131                                 proc->breakpoints = NULL;
 132                         }
 133                         return -1;
 134                 }
 135         }
 136
 137         /* Add process so that we know who the leader is.  */
 138         proc->pid = pid;
 139         if (add_process(proc, was_exec) < 0)
 140                 goto fail;
 141         if (proc->leader == NULL) {
 142         unlist_and_fail:
 143                 if (!was_exec)
 144                         unlist_process(proc);
 145                 goto fail;
 146         }
 147
 148         if (proc->leader == proc) {
 149                 proc->breakpoints = malloc(sizeof(*proc->breakpoints));
 150                 if (proc->breakpoints == NULL)
 151                         goto unlist_and_fail;
 152                 DICT_INIT(proc->breakpoints,
 153                           arch_addr_t, struct breakpoint *,
 154                           arch_addr_hash, arch_addr_eq, NULL);
 155         } else {
 156                 proc->breakpoints = NULL;
 157         }
 158
 159 #if defined(HAVE_LIBUNWIND)
 160         if (options.bt_depth > 0) {
 161                 proc->unwind_priv = _UPT_create(pid);
 162                 proc->unwind_as = unw_create_addr_space(&_UPT_accessors, 0);
 163
 164                 if (proc->unwind_priv == NULL || proc->unwind_as == NULL) {
 165                         fprintf(stderr,
 166                                 "Couldn't initialize unwinding "
 167                                 "for process %d\n", proc->pid);
 168                         destroy_unwind(proc);
 169                         proc->unwind_priv = NULL;
 170                         proc->unwind_as = NULL;
 171                 }
 172         }
 173 #endif /* defined(HAVE_LIBUNWIND) */
 174
 175 #if defined(HAVE_LIBDW)
 176         proc->dwfl = NULL; /* Initialize for leader only on first library.  */
 177 #endif /* defined(HAVE_LIBDW) */
 178
 179         return 0;
 180 }
 181
 182 static void
 183 process_bare_destroy(struct process *proc, int was_exec)
 184 {
 185         dict_destroy(proc->breakpoints, NULL, NULL, NULL);
 186         free(proc->breakpoints);
 187         if (!was_exec) {
 188                 free(proc->filename);
 189                 unlist_process(proc);
 190                 destroy_unwind(proc);
 191         }
 192 }
 193
 194 static int
 195 process_init_main(struct process *proc)
 196 {
 197         if (breakpoints_init(proc) < 0) {
 198                 fprintf(stderr, "failed to init breakpoints %d\n",
 199                         proc->pid);
 200                 return -1;
 201         }
 202
 203         return 0;
 204 }
 205
 206 int
 207 process_init(struct process *proc, const char *filename, pid_t pid)
 208 {
 209         if (process_bare_init(proc, filename, pid, 0) < 0) {
 210         fail:
 211                 fprintf(stderr, "failed to initialize process %d: %s\n",
 212                         pid, strerror(errno));
 213                 return -1;
 214         }
 215
 216         if (os_process_init(proc) < 0) {
 217                 process_bare_destroy(proc, 0);
 218                 goto fail;
 219         }
 220
 221         if (arch_process_init(proc) < 0) {
 222                 os_process_destroy(proc);
 223                 process_bare_destroy(proc, 0);
 224                 goto fail;
 225         }
 226
 227         if (proc->leader != proc) {
 228                 proc->e_machine = proc->leader->e_machine;
 229                 proc->e_class = proc->leader->e_class;
 230                 get_arch_dep(proc);
 231         } else if (process_init_main(proc) < 0) {
 232                 process_bare_destroy(proc, 0);
 233                 goto fail;
 234         }
 235         return 0;
 236 }
 237
 238 static enum callback_status
 239 destroy_breakpoint_cb(struct process *proc, struct breakpoint *bp, void *data)
 240 {
 241         breakpoint_destroy(bp);
 242         free(bp);
 243         return CBS_CONT;
 244 }
 245
 246 // XXX see comment in handle_event.c
 247 void callstack_pop(struct process *proc);
 248
 249 static void
 250 private_process_destroy(struct process *proc, int was_exec)
 251 {
 252         /* Pop remaining stack elements.  */
 253         while (proc->callstack_depth > 0) {
 254                 /* When this is called just before a process is
 255                  * destroyed, the breakpoints should either have been
 256                  * retracted by now, or were killed by exec.  In any
 257                  * case, it's safe to pretend that there are no
 258                  * breakpoints associated with the stack elements, so
 259                  * that stack_pop doesn't attempt to destroy them.  */
 260                 size_t i = proc->callstack_depth - 1;
 261                 if (!proc->callstack[i].is_syscall)
 262                         proc->callstack[i].return_addr = 0;
 263
 264                 callstack_pop(proc);
 265         }
 266
 267         if (!was_exec)
 268                 free(proc->filename);
 269
 270         /* Libraries and symbols.  This is only relevant in
 271          * leader.  */
 272         struct library *lib;
 273         for (lib = proc->libraries; lib != NULL; ) {
 274                 struct library *next = lib->next;
 275                 library_destroy(lib);
 276                 free(lib);
 277                 lib = next;
 278         }
 279         proc->libraries = NULL;
 280
 281         /* Breakpoints.  */
 282         if (proc->breakpoints != NULL) {
 283                 proc_each_breakpoint(proc, NULL, destroy_breakpoint_cb, NULL);
 284                 dict_destroy(proc->breakpoints, NULL, NULL, NULL);
 285                 free(proc->breakpoints);
 286                 proc->breakpoints = NULL;
 287         }
 288
 289         destroy_unwind(proc);
 290 }
 291
 292 void
 293 process_destroy(struct process *proc)
 294 {
 295         arch_process_destroy(proc);
 296         os_process_destroy(proc);
 297         private_process_destroy(proc, 0);
 298 }
 299
 300 int
 301 process_exec(struct process *proc)
 302 {
 303         /* Call exec handlers first, before we destroy the main
 304          * state.  */
 305         if (arch_process_exec(proc) < 0
 306             || os_process_exec(proc) < 0)
 307                 return -1;
 308
 309         private_process_destroy(proc, 1);
 310
 311         if (process_bare_init(proc, NULL, proc->pid, 1) < 0)
 312                 return -1;
 313         if (process_init_main(proc) < 0) {
 314                 process_bare_destroy(proc, 1);
 315                 return -1;
 316         }
 317         return 0;
 318 }
 319
 320 struct process *
 321 open_program(const char *filename, pid_t pid)
 322 {
 323         assert(pid != 0);
 324         struct process *proc = malloc(sizeof(*proc));
 325         if (proc == NULL || process_init(proc, filename, pid) < 0) {
 326                 free(proc);
 327                 return NULL;
 328         }
 329         return proc;
 330 }
 331
 332 struct clone_single_bp_data {
 333         struct process *old_proc;
 334         struct process *new_proc;
 335 };
 336
 337 static enum callback_status
 338 clone_single_bp(arch_addr_t *key, struct breakpoint **bpp, void *u)
 339 {
 340         struct breakpoint *bp = *bpp;
 341         struct clone_single_bp_data *data = u;
 342
 343         struct breakpoint *clone = malloc(sizeof(*clone));
 344         if (clone == NULL
 345             || breakpoint_clone(clone, data->new_proc, bp) < 0) {
 346         fail:
 347                 free(clone);
 348                 return CBS_STOP;
 349         }
 350         if (proc_add_breakpoint(data->new_proc->leader, clone) < 0) {
 351                 breakpoint_destroy(clone);
 352                 goto fail;
 353         }
 354         return CBS_CONT;
 355 }
 356
 357 int
 358 process_clone(struct process *retp, struct process *proc, pid_t pid)
 359 {
 360         if (process_bare_init(retp, proc->filename, pid, 0) < 0) {
 361         fail1:
 362                 fprintf(stderr, "Failed to clone process %d to %d: %s\n",
 363                         proc->pid, pid, strerror(errno));
 364                 return -1;
 365         }
 366
 367         retp->tracesysgood = proc->tracesysgood;
 368         retp->e_machine = proc->e_machine;
 369         retp->e_class = proc->e_class;
 370
 371         /* For non-leader processes, that's all we need to do.  */
 372         if (retp->leader != retp)
 373                 return 0;
 374
 375         /* Clone symbols first so that we can clone and relink
 376          * breakpoints.  */
 377         struct library *lib;
 378         struct library **nlibp = &retp->libraries;
 379         for (lib = proc->leader->libraries; lib != NULL; lib = lib->next) {
 380                 *nlibp = malloc(sizeof(**nlibp));
 381
 382                 if (*nlibp == NULL
 383                     || library_clone(*nlibp, lib) < 0) {
 384                         free(*nlibp);
 385                         *nlibp = NULL;
 386
 387                 fail2:
 388                         process_bare_destroy(retp, 0);
 389
 390                         /* Error when cloning.  Unroll what was done.  */
 391                         for (lib = retp->libraries; lib != NULL; ) {
 392                                 struct library *next = lib->next;
 393                                 library_destroy(lib);
 394                                 free(lib);
 395                                 lib = next;
 396                         }
 397                         goto fail1;
 398                 }
 399
 400                 nlibp = &(*nlibp)->next;
 401         }
 402
 403         /* Now clone breakpoints.  Symbol relinking is done in
 404          * clone_single_bp.  */
 405         struct clone_single_bp_data data = {
 406                 .old_proc = proc,
 407                 .new_proc = retp,
 408         };
 409         if (DICT_EACH(proc->leader->breakpoints,
 410                       arch_addr_t, struct breakpoint *, NULL,
 411                       clone_single_bp, &data) != NULL)
 412                 goto fail2;
 413
 414         /* And finally the call stack.  */
 415         /* XXX clearly the callstack handling should be moved to a
 416          * separate module and this whole business extracted to
 417          * callstack_clone, or callstack_element_clone.  */
 418         memcpy(retp->callstack, proc->callstack, sizeof(retp->callstack));
 419         retp->callstack_depth = proc->callstack_depth;
 420
 421         size_t i;
 422         for (i = 0; i < retp->callstack_depth; ++i) {
 423                 struct callstack_element *elem = &retp->callstack[i];
 424                 struct fetch_context *ctx = elem->fetch_context;
 425                 if (ctx != NULL) {
 426                         struct fetch_context *nctx = fetch_arg_clone(retp, ctx);
 427                         if (nctx == NULL) {
 428                                 size_t j;
 429                         fail3:
 430                                 for (j = 0; j < i; ++j) {
 431                                         nctx = retp->callstack[j].fetch_context;
 432                                         fetch_arg_done(nctx);
 433                                         elem->fetch_context = NULL;
 434                                 }
 435                                 goto fail2;
 436                         }
 437                         elem->fetch_context = nctx;
 438                 }
 439
 440                 if (elem->arguments != NULL) {
 441                         struct value_dict *nargs = malloc(sizeof(*nargs));
 442                         if (nargs == NULL
 443                             || val_dict_clone(nargs, elem->arguments) < 0) {
 444                                 size_t j;
 445                                 for (j = 0; j < i; ++j) {
 446                                         nargs = retp->callstack[j].arguments;
 447                                         val_dict_destroy(nargs);
 448                                         free(nargs);
 449                                         elem->arguments = NULL;
 450                                 }
 451
 452                                 /* Pretend that this round went well,
 453                                  * so that fail3 frees I-th
 454                                  * fetch_context.  */
 455                                 ++i;
 456                                 goto fail3;
 457                         }
 458                         elem->arguments = nargs;
 459                 }
 460
 461                 /* If it's not a syscall, we need to find the
 462                  * corresponding library symbol in the cloned
 463                  * library.  */
 464                 if (!elem->is_syscall && elem->c_un.libfunc != NULL) {
 465                         struct library_symbol *libfunc = elem->c_un.libfunc;
 466                         int rc = proc_find_symbol(retp, libfunc,
 467                                                   NULL, &elem->c_un.libfunc);
 468                         assert(rc == 0);
 469                 }
 470         }
 471
 472         /* At this point, retp is fully initialized, except for OS and
 473          * arch parts, and we can call private_process_destroy.  */
 474         if (os_process_clone(retp, proc) < 0) {
 475                 private_process_destroy(retp, 0);
 476                 return -1;
 477         }
 478         if (arch_process_clone(retp, proc) < 0) {
 479                 os_process_destroy(retp);
 480                 private_process_destroy(retp, 0);
 481                 return -1;
 482         }
 483
 484         return 0;
 485 }
 486
 487 static int
 488 open_one_pid(pid_t pid)
 489 {
 490         debug(DEBUG_PROCESS, "open_one_pid(pid=%d)", pid);
 491
 492         /* Get the filename first.  Should the trace_pid fail, we can
 493          * easily free it, untracing is more work.  */
 494         char *filename = pid2name(pid);
 495         if (filename == NULL || trace_pid(pid) < 0) {
 496         fail:
 497                 free(filename);
 498                 return -1;
 499         }
 500
 501         struct process *proc = open_program(filename, pid);
 502         if (proc == NULL)
 503                 goto fail;
 504         free(filename);
 505         trace_set_options(proc);
 506
 507         return 0;
 508 }
 509
 510 static enum callback_status
 511 start_one_pid(struct process *proc, void *data)
 512 {
 513         continue_process(proc->pid);
 514         return CBS_CONT;
 515 }
 516
 517 static enum callback_status
 518 is_main(struct process *proc, struct library *lib, void *data)
 519 {
 520         return CBS_STOP_IF(lib->type == LT_LIBTYPE_MAIN);
 521 }
 522
 523 void
 524 process_hit_start(struct process *proc)
 525 {
 526         struct process *leader = proc->leader;
 527         assert(leader != NULL);
 528
 529         struct library *mainlib
 530                 = proc_each_library(leader, NULL, is_main, NULL);
 531         assert(mainlib != NULL);
 532         linkmap_init(leader, mainlib->dyn_addr);
 533         arch_dynlink_done(leader);
 534 }
 535
 536 void
 537 open_pid(pid_t pid)
 538 {
 539         debug(DEBUG_PROCESS, "open_pid(pid=%d)", pid);
 540         /* If we are already tracing this guy, we should be seeing all
 541          * his children via normal tracing route.  */
 542         if (pid2proc(pid) != NULL)
 543                 return;
 544
 545         /* First, see if we can attach the requested PID itself.  */
 546         if (open_one_pid(pid) < 0) {
 547                 fprintf(stderr, "Cannot attach to pid %u: %s\n",
 548                         pid, strerror(errno));
 549                 trace_fail_warning(pid);
 550                 return;
 551         }
 552
 553         /* Now attach to all tasks that belong to that PID.  There's a
 554          * race between process_tasks and open_one_pid.  So when we
 555          * fail in open_one_pid below, we just do another round.
 556          * Chances are that by then that PID will have gone away, and
 557          * that's why we have seen the failure.  The processes that we
 558          * manage to open_one_pid are stopped, so we should eventually
 559          * reach a point where process_tasks doesn't give any new
 560          * processes (because there's nobody left to produce
 561          * them).  */
 562         size_t old_ntasks = 0;
 563         int have_all;
 564         while (1) {
 565                 pid_t *tasks;
 566                 size_t ntasks;
 567                 size_t i;
 568
 569                 if (process_tasks(pid, &tasks, &ntasks) < 0) {
 570                         fprintf(stderr, "Cannot obtain tasks of pid %u: %s\n",
 571                                 pid, strerror(errno));
 572                         break;
 573                 }
 574
 575                 have_all = 1;
 576                 for (i = 0; i < ntasks; ++i)
 577                         if (pid2proc(tasks[i]) == NULL
 578                             && open_one_pid(tasks[i]) < 0)
 579                                 have_all = 0;
 580
 581                 free(tasks);
 582
 583                 if (have_all && old_ntasks == ntasks)
 584                         break;
 585                 old_ntasks = ntasks;
 586         }
 587
 588         struct process *leader = pid2proc(pid)->leader;
 589
 590         /* XXX Is there a way to figure out whether _start has
 591          * actually already been hit?  */
 592         process_hit_start(leader);
 593
 594         /* Done.  Continue everyone.  */
 595         each_task(leader, NULL, start_one_pid, NULL);
 596 }
 597
 598 static enum callback_status
 599 find_proc(struct process *proc, void *data)
 600 {
 601         return CBS_STOP_IF(proc->pid == (pid_t)(uintptr_t)data);
 602 }
 603
 604 struct process *
 605 pid2proc(pid_t pid)
 606 {
 607         return each_process(NULL, &find_proc, (void *)(uintptr_t)pid);
 608 }
 609
 610 static struct process *list_of_processes = NULL;
 611
 612 static void
 613 unlist_process(struct process *proc)
 614 {
 615         if (list_of_processes == proc) {
 616                 list_of_processes = list_of_processes->next;
 617                 return;
 618         }
 619
 620         struct process *tmp;
 621         for (tmp = list_of_processes; ; tmp = tmp->next) {
 622                 /* If the following assert fails, the process wasn't
 623                  * in the list.  */
 624                 assert(tmp->next != NULL);
 625
 626                 if (tmp->next == proc) {
 627                         tmp->next = tmp->next->next;
 628                         return;
 629                 }
 630         }
 631 }
 632
 633 struct process *
 634 each_process(struct process *start_after,
 635              enum callback_status(*cb)(struct process *proc, void *data),
 636              void *data)
 637 {
 638         struct process *it = start_after == NULL ? list_of_processes
 639                 : start_after->next;
 640
 641         while (it != NULL) {
 642                 /* Callback might call remove_process.  */
 643                 struct process *next = it->next;
 644                 switch ((*cb)(it, data)) {
 645                 case CBS_FAIL:
 646                         /* XXX handle me */
 647                 case CBS_STOP:
 648                         return it;
 649                 case CBS_CONT:
 650                         break;
 651                 }
 652                 it = next;
 653         }
 654         return NULL;
 655 }
 656
 657 struct process *
 658 each_task(struct process *proc, struct process *start_after,
 659           enum callback_status(*cb)(struct process *proc, void *data),
 660           void *data)
 661 {
 662         assert(proc != NULL);
 663         struct process *it = start_after == NULL ? proc->leader
 664                 : start_after->next;
 665
 666         if (it != NULL) {
 667                 struct process *leader = it->leader;
 668                 while (it != NULL && it->leader == leader) {
 669                         /* Callback might call remove_process.  */
 670                         struct process *next = it->next;
 671                         switch ((*cb)(it, data)) {
 672                         case CBS_FAIL:
 673                                 /* XXX handle me */
 674                         case CBS_STOP:
 675                                 return it;
 676                         case CBS_CONT:
 677                                 break;
 678                         }
 679                         it = next;
 680                 }
 681         }
 682         return NULL;
 683 }
 684
 685 static int
 686 add_process(struct process *proc, int was_exec)
 687 {
 688         struct process **leaderp = &list_of_processes;
 689         if (proc->pid) {
 690                 pid_t tgid = process_leader(proc->pid);
 691                 if (tgid == 0)
 692                         /* Must have been terminated before we managed
 693                          * to fully attach.  */
 694                         return -1;
 695                 if (tgid == proc->pid) {
 696                         proc->leader = proc;
 697                 } else {
 698                         struct process *leader = pid2proc(tgid);
 699                         proc->leader = leader;
 700                         if (leader != NULL)
 701                                 leaderp = &leader->next;
 702                 }
 703         }
 704
 705         if (!was_exec) {
 706                 proc->next = *leaderp;
 707                 *leaderp = proc;
 708         }
 709         return 0;
 710 }
 711
 712 void
 713 change_process_leader(struct process *proc, struct process *leader)
 714 {
 715         struct process **leaderp = &list_of_processes;
 716         if (proc->leader == leader)
 717                 return;
 718
 719         assert(leader != NULL);
 720         unlist_process(proc);
 721         if (proc != leader)
 722                 leaderp = &leader->next;
 723
 724         proc->leader = leader;
 725         proc->next = *leaderp;
 726         *leaderp = proc;
 727 }
 728
 729 static enum callback_status
 730 clear_leader(struct process *proc, void *data)
 731 {
 732         debug(DEBUG_FUNCTION, "detach_task %d from leader %d",
 733               proc->pid, proc->leader->pid);
 734         proc->leader = NULL;
 735         return CBS_CONT;
 736 }
 737
 738 void
 739 remove_process(struct process *proc)
 740 {
 741         debug(DEBUG_FUNCTION, "remove_proc(pid=%d)", proc->pid);
 742
 743         if (proc->leader == proc)
 744                 each_task(proc, NULL, &clear_leader, NULL);
 745
 746         unlist_process(proc);
 747         process_removed(proc);
 748         process_destroy(proc);
 749         free(proc);
 750 }
 751
 752 void
 753 install_event_handler(struct process *proc, struct event_handler *handler)
 754 {
 755         debug(DEBUG_FUNCTION, "install_event_handler(pid=%d, %p)", proc->pid, handler);
 756         assert(proc->event_handler == NULL);
 757         proc->event_handler = handler;
 758 }
 759
 760 void
 761 destroy_event_handler(struct process *proc)
 762 {
 763         struct event_handler *handler = proc->event_handler;
 764         debug(DEBUG_FUNCTION, "destroy_event_handler(pid=%d, %p)", proc->pid, handler);
 765         assert(handler != NULL);
 766         if (handler->destroy != NULL)
 767                 handler->destroy(handler);
 768         free(handler);
 769         proc->event_handler = NULL;
 770 }
 771
 772 static int
 773 breakpoint_for_symbol(struct library_symbol *libsym, struct process *proc)
 774 {
 775         arch_addr_t bp_addr;
 776         assert(proc->leader == proc);
 777
 778         /* Don't enable latent or delayed symbols.  */
 779         if (libsym->latent || libsym->delayed) {
 780                 debug(DEBUG_FUNCTION,
 781                       "delayed and/or latent breakpoint pid=%d, %s@%p",
 782                       proc->pid, libsym->name, libsym->enter_addr);
 783                 return 0;
 784         }
 785
 786         bp_addr = sym2addr(proc, libsym);
 787
 788         /* If there is an artificial breakpoint on the same address,
 789          * its libsym will be NULL, and we can smuggle our libsym
 790          * there.  That artificial breakpoint is there presumably for
 791          * the callbacks, which we don't touch.  If there is a real
 792          * breakpoint, then this is a bug.  ltrace-elf.c should filter
 793          * symbols and ignore extra symbol aliases.
 794          *
 795          * The other direction is more complicated and currently not
 796          * supported.  If a breakpoint has custom callbacks, it might
 797          * be also custom-allocated, and we would really need to swap
 798          * the two: delete the one now in the dictionary, swap values
 799          * around, and put the new breakpoint back in.  */
 800         struct breakpoint *bp;
 801         if (DICT_FIND_VAL(proc->breakpoints, &bp_addr, &bp) == 0) {
 802                 /* MIPS backend makes duplicate requests.  This is
 803                  * likely a bug in the backend.  Currently there's no
 804                  * point assigning more than one symbol to a
 805                  * breakpoint, because when it hits, we won't know
 806                  * what to print out.  But it's easier to fix it here
 807                  * before someone who understands MIPS has the time to
 808                  * look into it.  So turn the sanity check off on
 809                  * MIPS.  References:
 810                  *
 811                  *   http://lists.alioth.debian.org/pipermail/ltrace-devel/2012-November/000764.html
 812                  *   http://lists.alioth.debian.org/pipermail/ltrace-devel/2012-November/000770.html
 813                  */
 814 #ifndef __mips__
 815                 assert(bp->libsym == NULL);
 816                 bp->libsym = libsym;
 817 #endif
 818                 return 0;
 819         }
 820
 821         bp = malloc(sizeof(*bp));
 822         if (bp == NULL
 823             || breakpoint_init(bp, proc, bp_addr, libsym) < 0) {
 824         fail:
 825                 free(bp);
 826                 return -1;
 827         }
 828         if (proc_add_breakpoint(proc, bp) < 0) {
 829                 breakpoint_destroy(bp);
 830                 goto fail;
 831         }
 832
 833         if (breakpoint_turn_on(bp, proc) < 0) {
 834                 proc_remove_breakpoint(proc, bp);
 835                 breakpoint_destroy(bp);
 836                 goto fail;
 837         }
 838
 839         return 0;
 840 }
 841
 842 static enum callback_status
 843 cb_breakpoint_for_symbol(struct library_symbol *libsym, void *data)
 844 {
 845         return CBS_STOP_IF(breakpoint_for_symbol(libsym, data) < 0);
 846 }
 847
 848 static int
 849 proc_activate_latent_symbol(struct process *proc,
 850                             struct library_symbol *libsym)
 851 {
 852         assert(libsym->latent);
 853         libsym->latent = 0;
 854         debug(DEBUG_FUNCTION, "activated latent symbol");
 855         return breakpoint_for_symbol(libsym, proc);
 856 }
 857
 858 int
 859 proc_activate_delayed_symbol(struct process *proc,
 860                              struct library_symbol *libsym)
 861 {
 862         assert(libsym->delayed);
 863         libsym->delayed = 0;
 864         debug(DEBUG_FUNCTION, "activated delayed symbol");
 865         return breakpoint_for_symbol(libsym, proc);
 866 }
 867
 868 static enum callback_status
 869 activate_latent_in(struct process *proc, struct library *lib, void *data)
 870 {
 871         struct library_exported_name *exported;
 872         for (exported = data; exported != NULL; exported = exported->next) {
 873                 struct library_symbol *libsym = NULL;
 874                 while ((libsym = library_each_symbol(lib, libsym,
 875                                                      library_symbol_named_cb,
 876                                                      (void *)exported->name))
 877                        != NULL)
 878                         if (libsym->latent
 879                             && proc_activate_latent_symbol(proc, libsym) < 0)
 880                                 return CBS_FAIL;
 881         }
 882         return CBS_CONT;
 883 }
 884
 885 void
 886 proc_add_library(struct process *proc, struct library *lib)
 887 {
 888         assert(lib->next == NULL);
 889         lib->next = proc->libraries;
 890         proc->libraries = lib;
 891         debug(DEBUG_PROCESS, "added library %s@%p (%s) to %d",
 892               lib->soname, lib->base, lib->pathname, proc->pid);
 893
 894 #if defined(HAVE_LIBDW)
 895         if (options.bt_depth > 0) {
 896                 /* Setup module tracking for libdwfl unwinding.  */
 897                 struct process *leader = proc->leader;
 898                 Dwfl *dwfl = leader->dwfl;
 899                 if (dwfl == NULL) {
 900                         static const Dwfl_Callbacks proc_callbacks = {
 901                                 .find_elf = dwfl_linux_proc_find_elf,
 902                                 .find_debuginfo = dwfl_standard_find_debuginfo
 903                         };
 904                         dwfl = dwfl_begin(&proc_callbacks);
 905                         if (dwfl == NULL)
 906                                 fprintf(stderr,
 907                                         "Couldn't initialize libdwfl unwinding "
 908                                         "for process %d: %s\n", leader->pid,
 909                                         dwfl_errmsg (-1));
 910                 }
 911
 912                 if (dwfl != NULL) {
 913                         dwfl_report_begin_add(dwfl);
 914                         if (dwfl_report_elf(dwfl, lib->soname,
 915                                             lib->pathname, -1,
 916                                             (GElf_Addr) lib->base,
 917                                             false) == NULL)
 918                                 fprintf(stderr,
 919                                         "dwfl_report_elf %s@%p (%s) %d: %s\n",
 920                                         lib->soname, lib->base, lib->pathname,
 921                                         proc->pid, dwfl_errmsg (-1));
 922                         dwfl_report_end(dwfl, NULL, NULL);
 923
 924                         if (leader->dwfl == NULL) {
 925                                 int r = dwfl_linux_proc_attach(dwfl,
 926                                                                leader->pid,
 927                                                                true);
 928                                 if (r == 0)
 929                                         leader->dwfl = dwfl;
 930                                 else {
 931                                         const char *msg;
 932                                         dwfl_end(dwfl);
 933                                         if (r < 0)
 934                                                 msg = dwfl_errmsg(-1);
 935                                         else
 936                                                 msg = strerror(r);
 937                                         fprintf(stderr, "Couldn't initialize "
 938                                                 "libdwfl unwinding for "
 939                                                 "process %d: %s\n",
 940                                                 leader->pid, msg);
 941                                 }
 942                         }
 943                 }
 944         }
 945 #endif /* defined(HAVE_LIBDW) */
 946
 947         /* Insert breakpoints for all active (non-latent) symbols.  */
 948         struct library_symbol *libsym = NULL;
 949         while ((libsym = library_each_symbol(lib, libsym,
 950                                              cb_breakpoint_for_symbol,
 951                                              proc)) != NULL)
 952                 fprintf(stderr,
 953                         "Couldn't insert breakpoint for %s to %d: %s.\n",
 954                         libsym->name, proc->pid, strerror(errno));
 955
 956         /* Look through export list of the new library and compare it
 957          * with latent symbols of all libraries (including this
 958          * library itself).  */
 959         struct library *lib2 = NULL;
 960         while ((lib2 = proc_each_library(proc, lib2, activate_latent_in,
 961                                          lib->exported_names)) != NULL)
 962                 fprintf(stderr,
 963                         "Couldn't activate latent symbols for %s in %d: %s.\n",
 964                         lib2->soname, proc->pid, strerror(errno));
 965 }
 966
 967 int
 968 proc_remove_library(struct process *proc, struct library *lib)
 969 {
 970         struct library **libp;
 971         for (libp = &proc->libraries; *libp != NULL; libp = &(*libp)->next)
 972                 if (*libp == lib) {
 973                         *libp = lib->next;
 974                         return 0;
 975                 }
 976         return -1;
 977 }
 978
 979 struct library *
 980 proc_each_library(struct process *proc, struct library *it,
 981                   enum callback_status (*cb)(struct process *proc,
 982                                              struct library *lib, void *data),
 983                   void *data)
 984 {
 985         if (it == NULL)
 986                 it = proc->libraries;
 987         else
 988                 it = it->next;
 989
 990         while (it != NULL) {
 991                 struct library *next = it->next;
 992
 993                 switch (cb(proc, it, data)) {
 994                 case CBS_FAIL:
 995                         /* XXX handle me */
 996                 case CBS_STOP:
 997                         return it;
 998                 case CBS_CONT:
 999                         break;
1000                 }
1001
1002                 it = next;
1003         }
1004
1005         return NULL;
1006 }
1007
1008 static void
1009 check_leader(struct process *proc)
1010 {
1011         /* Only the group leader should be getting the breakpoints and
1012          * thus have ->breakpoint initialized.  */
1013         assert(proc->leader != NULL);
1014         assert(proc->leader == proc);
1015         assert(proc->breakpoints != NULL);
1016 }
1017
1018 int
1019 proc_add_breakpoint(struct process *proc, struct breakpoint *bp)
1020 {
1021         debug(DEBUG_FUNCTION, "proc_add_breakpoint(pid=%d, %s@%p)",
1022               proc->pid, breakpoint_name(bp), bp->addr);
1023         check_leader(proc);
1024
1025         /* XXX We might merge bp->libsym instead of the following
1026          * assert, but that's not necessary right now.  Read the
1027          * comment in breakpoint_for_symbol.  */
1028         assert(dict_find(proc->breakpoints, &bp->addr) == NULL);
1029
1030         if (DICT_INSERT(proc->breakpoints, &bp->addr, &bp) < 0) {
1031                 fprintf(stderr,
1032                         "couldn't enter breakpoint %s@%p to dictionary: %s\n",
1033                         breakpoint_name(bp), bp->addr, strerror(errno));
1034                 return -1;
1035         }
1036
1037         return 0;
1038 }
1039
1040 void
1041 proc_remove_breakpoint(struct process *proc, struct breakpoint *bp)
1042 {
1043         debug(DEBUG_FUNCTION, "proc_remove_breakpoint(pid=%d, %s@%p)",
1044               proc->pid, breakpoint_name(bp), bp->addr);
1045         check_leader(proc);
1046         int rc = DICT_ERASE(proc->breakpoints, &bp->addr, struct breakpoint *,
1047                             NULL, NULL, NULL);
1048         assert(rc == 0);
1049 }
1050
1051 struct each_breakpoint_data
1052 {
1053         struct process *proc;
1054         enum callback_status (*cb)(struct process *proc,
1055                                    struct breakpoint *bp,
1056                                    void *data);
1057         void *cb_data;
1058 };
1059
1060 static enum callback_status
1061 each_breakpoint_cb(arch_addr_t *key, struct breakpoint **bpp, void *d)
1062 {
1063         struct each_breakpoint_data *data = d;
1064         return data->cb(data->proc, *bpp, data->cb_data);
1065 }
1066
1067 arch_addr_t *
1068 proc_each_breakpoint(struct process *proc, arch_addr_t *start,
1069                      enum callback_status (*cb)(struct process *proc,
1070                                                 struct breakpoint *bp,
1071                                                 void *data), void *data)
1072 {
1073         struct each_breakpoint_data dd = {
1074                 .proc = proc,
1075                 .cb = cb,
1076                 .cb_data = data,
1077         };
1078         return DICT_EACH(proc->breakpoints,
1079                          arch_addr_t, struct breakpoint *, start,
1080                          &each_breakpoint_cb, &dd);
1081 }
1082
1083 int
1084 proc_find_symbol(struct process *proc, struct library_symbol *sym,
1085                  struct library **retlib, struct library_symbol **retsym)
1086 {
1087         struct library *lib = sym->lib;
1088         assert(lib != NULL);
1089
1090         struct library *flib
1091                 = proc_each_library(proc, NULL, library_with_key_cb, &lib->key);
1092         if (flib == NULL)
1093                 return -1;
1094
1095         struct library_symbol *fsym
1096                 = library_each_symbol(flib, NULL, library_symbol_named_cb,
1097                                       (char *)sym->name);
1098         if (fsym == NULL)
1099                 return -1;
1100
1101         if (retlib != NULL)
1102                 *retlib = flib;
1103         if (retsym != NULL)
1104                 *retsym = fsym;
1105
1106         return 0;
1107 }
1108
1109 struct library_symbol *
1110 proc_each_symbol(struct process *proc, struct library_symbol *start_after,
1111                  enum callback_status (*cb)(struct library_symbol *, void *),
1112                  void *data)
1113 {
1114         struct library *lib;
1115         for (lib = start_after != NULL ? start_after->lib : proc->libraries;
1116              lib != NULL; lib = lib->next) {
1117                 start_after = library_each_symbol(lib, start_after, cb, data);
1118                 if (start_after != NULL)
1119                         return start_after;
1120         }
1121
1122         return NULL;
1123 }
1124
1125 #define DEF_READER(NAME, SIZE)                                          \
1126         int                                                             \
1127         NAME(struct process *proc, arch_addr_t addr,                    \
1128              uint##SIZE##_t *lp)                                        \
1129         {                                                               \
1130                 union {                                                 \
1131                         uint##SIZE##_t dst;                             \
1132                         char buf[0];                                    \
1133                 } u;                                                    \
1134                 if (umovebytes(proc, addr, &u.buf, sizeof(u.dst))       \
1135                     != sizeof(u.dst))                                   \
1136                         return -1;                                      \
1137                 *lp = u.dst;                                            \
1138                 return 0;                                               \
1139         }
1140
1141 DEF_READER(proc_read_8, 8)
1142 DEF_READER(proc_read_16, 16)
1143 DEF_READER(proc_read_32, 32)
1144 DEF_READER(proc_read_64, 64)
1145
1146 #undef DEF_READER