proc.c revision 75934ad3b30790f6a892069576d0790a351ef101
1#include "config.h" 2 3#if defined(HAVE_LIBUNWIND) 4#include <libunwind.h> 5#include <libunwind-ptrace.h> 6#endif /* defined(HAVE_LIBUNWIND) */ 7 8#include <sys/types.h> 9#include <string.h> 10#include <stdio.h> 11#include <errno.h> 12#include <stdlib.h> 13#include <assert.h> 14#include <error.h> 15 16#include "common.h" 17#include "breakpoint.h" 18#include "proc.h" 19 20static void add_process(struct Process *proc); 21 22static int 23process_bare_init(struct Process *proc, const char *filename, pid_t pid) 24{ 25 memset(proc, 0, sizeof(*proc)); 26 27 proc->filename = strdup(filename); 28 if (proc->filename == NULL) { 29 fail: 30 free(proc->filename); 31 if (proc->breakpoints != NULL) 32 dict_clear(proc->breakpoints); 33 return -1; 34 } 35 36 /* Add process so that we know who the leader is. */ 37 proc->pid = pid; 38 add_process(proc); 39 if (proc->leader == NULL) 40 goto fail; 41 42 if (proc->leader == proc) { 43 proc->breakpoints = dict_init(target_address_hash, 44 target_address_cmp); 45 if (proc->breakpoints == NULL) 46 goto fail; 47 } else { 48 proc->breakpoints = NULL; 49 } 50 51#if defined(HAVE_LIBUNWIND) 52 proc->unwind_priv = _UPT_create(pid); 53 proc->unwind_as = unw_create_addr_space(&_UPT_accessors, 0); 54#endif /* defined(HAVE_LIBUNWIND) */ 55 56 return 0; 57} 58 59static void 60process_bare_destroy(struct Process *proc) 61{ 62 free(proc->filename); 63 dict_clear(proc->breakpoints); 64 remove_process(proc); 65} 66 67int 68process_init(struct Process *proc, const char *filename, pid_t pid, int enable) 69{ 70 if (process_bare_init(proc, filename, pid) < 0) { 71 error(0, errno, "init process %d", pid); 72 return -1; 73 } 74 75 /* For secondary threads, this is all that we need to do. */ 76 if (proc->leader != proc) 77 return 0; 78 79 target_address_t entry; 80 target_address_t interp_bias; 81 if (process_get_entry(proc, &entry, &interp_bias) < 0) { 82 fprintf(stderr, "Couldn't get entry points of process %d\n", 83 proc->pid); 84 fail: 85 process_bare_destroy(proc); 86 return -1; 87 } 88 89 if (breakpoints_init(proc, enable) < 0) { 90 fprintf(stderr, "failed to init breakpoints %d\n", 91 proc->pid); 92 goto fail; 93 } 94 95 return 0; 96} 97 98struct Process * 99open_program(const char *filename, pid_t pid) 100{ 101 assert(pid != 0); 102 struct Process *proc = malloc(sizeof(*proc)); 103 if (proc == NULL || process_init(proc, filename, pid) < 0) { 104 free(proc); 105 return NULL; 106 } 107 return proc; 108} 109 110struct clone_single_bp_data { 111 struct Process *old_proc; 112 struct Process *new_proc; 113 int error; 114}; 115 116static void 117clone_single_bp(void *key, void *value, void *u) 118{ 119 struct breakpoint *bp = value; 120 struct clone_single_bp_data *data = u; 121 122 data->error = 0; 123 struct breakpoint *clone = malloc(sizeof(*clone)); 124 if (clone == NULL 125 || breakpoint_clone(clone, data->new_proc, 126 bp, data->old_proc) < 0) { 127 fail: 128 free(clone); 129 data->error = -1; 130 } 131 if (proc_add_breakpoint(data->new_proc->leader, clone) < 0) { 132 breakpoint_destroy(clone); 133 goto fail; 134 } 135} 136 137int 138process_clone(struct Process *retp, struct Process *proc, pid_t pid) 139{ 140 if (process_bare_init(retp, proc->filename, pid) < 0) { 141 fail: 142 error(0, errno, "clone process %d->%d", proc->pid, pid); 143 return -1; 144 } 145 146 retp->tracesysgood = proc->tracesysgood; 147 148 /* For non-leader processes, that's all we need to do. */ 149 if (retp->leader != retp) 150 return 0; 151 152 /* Clone symbols first so that we can clone and relink 153 * breakpoints. */ 154 struct library *lib; 155 struct library **nlibp = &retp->libraries; 156 for (lib = proc->libraries; lib != NULL; lib = lib->next) { 157 *nlibp = malloc(sizeof(**nlibp)); 158 if (*nlibp == NULL 159 || library_clone(*nlibp, lib) < 0) { 160 fail2: 161 process_bare_destroy(retp); 162 163 /* Error when cloning. Unroll what was done. */ 164 for (lib = retp->libraries; lib != NULL; ) { 165 struct library *next = lib->next; 166 library_destroy(lib); 167 free(lib); 168 lib = next; 169 } 170 goto fail; 171 } 172 173 nlibp = &(*nlibp)->next; 174 } 175 176 /* Now clone breakpoints. Symbol relinking is done in 177 * clone_single_bp. */ 178 struct clone_single_bp_data data = { 179 .old_proc = proc, 180 .new_proc = retp, 181 .error = 0, 182 }; 183 dict_apply_to_all(proc->breakpoints, &clone_single_bp, &data); 184 185 /* And finally the call stack. */ 186 memcpy(retp->callstack, proc->callstack, sizeof(retp->callstack)); 187 retp->callstack_depth = proc->callstack_depth; 188 189 if (data.error < 0) 190 goto fail2; 191 192 return 0; 193} 194 195static int 196open_one_pid(pid_t pid) 197{ 198 Process *proc; 199 char *filename; 200 debug(DEBUG_PROCESS, "open_one_pid(pid=%d)", pid); 201 202 /* Get the filename first. Should the trace_pid fail, we can 203 * easily free it, untracing is more work. */ 204 if ((filename = pid2name(pid)) == NULL 205 || trace_pid(pid) < 0) { 206 free(filename); 207 return -1; 208 } 209 210 proc = open_program(filename, pid); 211 if (proc == NULL) 212 return -1; 213 trace_set_options(proc); 214 215 return 0; 216} 217 218static enum callback_status 219start_one_pid(Process * proc, void * data) 220{ 221 continue_process(proc->pid); 222 return CBS_CONT; 223} 224 225void 226open_pid(pid_t pid) 227{ 228 debug(DEBUG_PROCESS, "open_pid(pid=%d)", pid); 229 /* If we are already tracing this guy, we should be seeing all 230 * his children via normal tracing route. */ 231 if (pid2proc(pid) != NULL) 232 return; 233 234 /* First, see if we can attach the requested PID itself. */ 235 if (open_one_pid(pid)) { 236 fprintf(stderr, "Cannot attach to pid %u: %s\n", 237 pid, strerror(errno)); 238 trace_fail_warning(pid); 239 return; 240 } 241 242 /* Now attach to all tasks that belong to that PID. There's a 243 * race between process_tasks and open_one_pid. So when we 244 * fail in open_one_pid below, we just do another round. 245 * Chances are that by then that PID will have gone away, and 246 * that's why we have seen the failure. The processes that we 247 * manage to open_one_pid are stopped, so we should eventually 248 * reach a point where process_tasks doesn't give any new 249 * processes (because there's nobody left to produce 250 * them). */ 251 size_t old_ntasks = 0; 252 int have_all; 253 while (1) { 254 pid_t *tasks; 255 size_t ntasks; 256 size_t i; 257 258 if (process_tasks(pid, &tasks, &ntasks) < 0) { 259 fprintf(stderr, "Cannot obtain tasks of pid %u: %s\n", 260 pid, strerror(errno)); 261 break; 262 } 263 264 have_all = 1; 265 for (i = 0; i < ntasks; ++i) 266 if (pid2proc(tasks[i]) == NULL 267 && open_one_pid(tasks[i])) 268 have_all = 0; 269 270 free(tasks); 271 272 if (have_all && old_ntasks == ntasks) 273 break; 274 old_ntasks = ntasks; 275 } 276 277 /* Done. Now initialize breakpoints and then continue 278 * everyone. */ 279 Process * leader; 280 leader = pid2proc(pid)->leader; 281 enable_all_breakpoints(leader); 282 283 each_task(pid2proc(pid)->leader, NULL, start_one_pid, NULL); 284} 285 286static enum callback_status 287find_proc(Process * proc, void * data) 288{ 289 pid_t pid = (pid_t)(uintptr_t)data; 290 return proc->pid == pid ? CBS_STOP : CBS_CONT; 291} 292 293Process * 294pid2proc(pid_t pid) { 295 return each_process(NULL, &find_proc, (void *)(uintptr_t)pid); 296} 297 298static Process * list_of_processes = NULL; 299 300static void 301unlist_process(Process * proc) 302{ 303 Process *tmp; 304 305 if (list_of_processes == proc) { 306 list_of_processes = list_of_processes->next; 307 return; 308 } 309 310 for (tmp = list_of_processes; ; tmp = tmp->next) { 311 /* If the following assert fails, the process wasn't 312 * in the list. */ 313 assert(tmp->next != NULL); 314 315 if (tmp->next == proc) { 316 tmp->next = tmp->next->next; 317 return; 318 } 319 } 320} 321 322struct Process * 323each_process(struct Process *start_after, 324 enum callback_status(*cb)(struct Process *proc, void *data), 325 void *data) 326{ 327 struct Process *it = start_after == NULL ? list_of_processes 328 : start_after->next; 329 330 while (it != NULL) { 331 /* Callback might call remove_process. */ 332 struct Process *next = it->next; 333 switch ((*cb)(it, data)) { 334 case CBS_FAIL: 335 /* XXX handle me */ 336 case CBS_STOP: 337 return it; 338 case CBS_CONT: 339 break; 340 } 341 it = next; 342 } 343 return NULL; 344} 345 346Process * 347each_task(struct Process *proc, struct Process *start_after, 348 enum callback_status(*cb)(struct Process *proc, void *data), 349 void *data) 350{ 351 assert(proc != NULL); 352 struct Process *it = start_after == NULL ? proc->leader 353 : start_after->next; 354 355 if (it != NULL) { 356 struct Process *leader = it->leader; 357 while (it != NULL && it->leader == leader) { 358 /* Callback might call remove_process. */ 359 struct Process *next = it->next; 360 switch ((*cb)(it, data)) { 361 case CBS_FAIL: 362 /* XXX handle me */ 363 case CBS_STOP: 364 return it; 365 case CBS_CONT: 366 break; 367 } 368 it = next; 369 } 370 } 371 return NULL; 372} 373 374static void 375add_process(Process * proc) 376{ 377 Process ** leaderp = &list_of_processes; 378 if (proc->pid) { 379 pid_t tgid = process_leader(proc->pid); 380 if (tgid == 0) 381 /* Must have been terminated before we managed 382 * to fully attach. */ 383 return; 384 if (tgid == proc->pid) 385 proc->leader = proc; 386 else { 387 Process * leader = pid2proc(tgid); 388 proc->leader = leader; 389 if (leader != NULL) 390 leaderp = &leader->next; 391 } 392 } 393 proc->next = *leaderp; 394 *leaderp = proc; 395} 396 397void 398change_process_leader(Process * proc, Process * leader) 399{ 400 Process ** leaderp = &list_of_processes; 401 if (proc->leader == leader) 402 return; 403 404 assert(leader != NULL); 405 unlist_process(proc); 406 if (proc != leader) 407 leaderp = &leader->next; 408 409 proc->leader = leader; 410 proc->next = *leaderp; 411 *leaderp = proc; 412} 413 414static enum callback_status 415clear_leader(struct Process *proc, void *data) 416{ 417 debug(DEBUG_FUNCTION, "detach_task %d from leader %d", 418 proc->pid, proc->leader->pid); 419 proc->leader = NULL; 420 return CBS_CONT; 421} 422 423static enum ecb_status 424event_for_proc(Event * event, void * data) 425{ 426 if (event->proc == data) 427 return ecb_deque; 428 else 429 return ecb_cont; 430} 431 432static void 433delete_events_for(Process * proc) 434{ 435 Event * event; 436 while ((event = each_qd_event(&event_for_proc, proc)) != NULL) 437 free(event); 438} 439 440void 441remove_process(Process *proc) 442{ 443 debug(DEBUG_FUNCTION, "remove_proc(pid=%d)", proc->pid); 444 445 if (proc->leader == proc) 446 each_task(proc, NULL, &clear_leader, NULL); 447 448 unlist_process(proc); 449 delete_events_for(proc); 450} 451 452void 453install_event_handler(Process *proc, struct event_handler *handler) 454{ 455 debug(DEBUG_FUNCTION, "install_event_handler(pid=%d, %p)", proc->pid, handler); 456 assert(proc->event_handler == NULL); 457 proc->event_handler = handler; 458} 459 460void 461destroy_event_handler(Process * proc) 462{ 463 struct event_handler *handler = proc->event_handler; 464 debug(DEBUG_FUNCTION, "destroy_event_handler(pid=%d, %p)", proc->pid, handler); 465 assert(handler != NULL); 466 if (handler->destroy != NULL) 467 handler->destroy(handler); 468 free(handler); 469 proc->event_handler = NULL; 470} 471 472static enum callback_status 473breakpoint_for_symbol(struct library_symbol *libsym, void *data) 474{ 475 struct Process *proc = data; 476 assert(proc->leader == proc); 477 478 /* If there is an artificial breakpoint on the same address, 479 * its libsym will be NULL, and we can smuggle our libsym 480 * there. That artificial breakpoint is there presumably for 481 * the callbacks, which we don't touch. If there is a real 482 * breakpoint, then this is a bug. ltrace-elf.c should filter 483 * symbols and ignore extra symbol aliases. 484 * 485 * The other direction is more complicated and currently not 486 * supported. If a breakpoint has custom callbacks, it might 487 * be also custom-allocated, and we would really need to swap 488 * the two: delete the one now in the dictionary, swap values 489 * around, and put the new breakpoint back in. */ 490 struct breakpoint *bp = dict_find_entry(proc->breakpoints, 491 libsym->enter_addr); 492 if (bp != NULL) { 493 assert(bp->libsym == NULL); 494 bp->libsym = libsym; 495 return CBS_CONT; 496 } 497 498 bp = malloc(sizeof(*bp)); 499 if (bp == NULL 500 || breakpoint_init(bp, proc, libsym->enter_addr, libsym) < 0) { 501 fail: 502 free(bp); 503 return CBS_FAIL; 504 } 505 if (proc_add_breakpoint(proc, bp) < 0) { 506 breakpoint_destroy(bp); 507 goto fail; 508 } 509 510 if (breakpoint_turn_on(bp, proc) < 0) { 511 proc_remove_breakpoint(proc, bp); 512 breakpoint_destroy(bp); 513 goto fail; 514 } 515 516 return CBS_CONT; 517} 518 519void 520proc_add_library(struct Process *proc, struct library *lib) 521{ 522 assert(lib->next == NULL); 523 lib->next = proc->libraries; 524 proc->libraries = lib; 525 debug(DEBUG_PROCESS, "added library %s@%p (%s) to %d", 526 lib->soname, lib->base, lib->pathname, proc->pid); 527 528 struct library_symbol *libsym = NULL; 529 while ((libsym = library_each_symbol(lib, libsym, breakpoint_for_symbol, 530 proc)) != NULL) 531 error(0, errno, "insert breakpoint for %s", libsym->name); 532} 533 534int 535proc_remove_library(struct Process *proc, struct library *lib) 536{ 537 struct library **libp; 538 for (libp = &proc->libraries; *libp != NULL; libp = &(*libp)->next) 539 if (*libp == lib) { 540 *libp = lib->next; 541 return 0; 542 } 543 return -1; 544} 545 546struct library * 547proc_each_library(struct Process *proc, struct library *it, 548 enum callback_status (*cb)(struct Process *proc, 549 struct library *lib, void *data), 550 void *data) 551{ 552 if (it == NULL) 553 it = proc->libraries; 554 555 while (it != NULL) { 556 struct library *next = it->next; 557 558 switch (cb(proc, it, data)) { 559 case CBS_FAIL: 560 /* XXX handle me */ 561 case CBS_STOP: 562 return it; 563 case CBS_CONT: 564 break; 565 } 566 567 it = next; 568 } 569 570 return NULL; 571} 572 573int 574proc_add_breakpoint(struct Process *proc, struct breakpoint *bp) 575{ 576 /* Only the group leader should be getting the breakpoints and 577 * thus have ->breakpoint initialized. */ 578 assert(proc->leader != NULL); 579 assert(proc->leader == proc); 580 assert(proc->breakpoints != NULL); 581 582 debug(DEBUG_FUNCTION, "proc_add_breakpoint(pid=%d, %s@%p)", 583 proc->pid, breakpoint_name(bp), bp->addr); 584 585 /* XXX We might merge bp->libsym instead of the following 586 * assert, but that's not necessary right now. Read the 587 * comment in breakpoint_for_symbol. */ 588 assert(dict_find_entry(proc->breakpoints, bp->addr) == NULL); 589 590 if (dict_enter(proc->breakpoints, bp->addr, bp) < 0) { 591 error(0, errno, "couldn't enter breakpoint %s@%p to dictionary", 592 breakpoint_name(bp), bp->addr); 593 return -1; 594 } 595 596 return 0; 597} 598 599int 600proc_remove_breakpoint(struct Process *proc, struct breakpoint *bp) 601{ 602 /* XXX We can't, really. We are missing dict_remove. */ 603 assert(!"Not yet implemented!"); 604 abort(); 605} 606 607/* Dict doesn't support iteration restarts, so here's this contraption 608 * for now. XXX add restarts to dict. */ 609struct each_breakpoint_data 610{ 611 void *start; 612 void *end; 613 struct Process *proc; 614 enum callback_status (*cb)(struct Process *proc, 615 struct breakpoint *bp, 616 void *data); 617 void *cb_data; 618}; 619 620static void 621each_breakpoint_cb(void *key, void *value, void *d) 622{ 623 struct each_breakpoint_data *data = d; 624 if (data->end != NULL) 625 return; 626 if (data->start == key) 627 data->start = NULL; 628 629 if (data->start == NULL) { 630 switch (data->cb(data->proc, value, data->cb_data)) { 631 case CBS_FAIL: 632 /* XXX handle me */ 633 case CBS_STOP: 634 data->end = key; 635 case CBS_CONT: 636 return; 637 } 638 } 639} 640 641void * 642proc_each_breakpoint(struct Process *proc, void *start, 643 enum callback_status (*cb)(struct Process *proc, 644 struct breakpoint *bp, 645 void *data), void *data) 646{ 647 struct each_breakpoint_data dd = { 648 .start = start, 649 .proc = proc, 650 .cb = cb, 651 .cb_data = data, 652 }; 653 dict_apply_to_all(proc->breakpoints, &each_breakpoint_cb, &dd); 654 return dd.end; 655} 656