trace.c revision ec85e84d2d3dc441dc2f1a6b403ed495cefd2c5b
1#include <stdio.h> 2#include <stdlib.h> 3#include <string.h> 4#include <errno.h> 5#include <unistd.h> 6#include <sys/types.h> 7#include <sys/wait.h> 8#include "ptrace.h" 9#include <asm/unistd.h> 10#include <assert.h> 11 12#include "common.h" 13 14/* If the system headers did not provide the constants, hard-code the normal 15 values. */ 16#ifndef PTRACE_EVENT_FORK 17 18#define PTRACE_OLDSETOPTIONS 21 19#define PTRACE_SETOPTIONS 0x4200 20#define PTRACE_GETEVENTMSG 0x4201 21 22/* options set using PTRACE_SETOPTIONS */ 23#define PTRACE_O_TRACESYSGOOD 0x00000001 24#define PTRACE_O_TRACEFORK 0x00000002 25#define PTRACE_O_TRACEVFORK 0x00000004 26#define PTRACE_O_TRACECLONE 0x00000008 27#define PTRACE_O_TRACEEXEC 0x00000010 28#define PTRACE_O_TRACEVFORKDONE 0x00000020 29#define PTRACE_O_TRACEEXIT 0x00000040 30 31/* Wait extended result codes for the above trace options. */ 32#define PTRACE_EVENT_FORK 1 33#define PTRACE_EVENT_VFORK 2 34#define PTRACE_EVENT_CLONE 3 35#define PTRACE_EVENT_EXEC 4 36#define PTRACE_EVENT_VFORK_DONE 5 37#define PTRACE_EVENT_EXIT 6 38 39#endif /* PTRACE_EVENT_FORK */ 40 41#ifdef ARCH_HAVE_UMOVELONG 42extern int arch_umovelong (Process *, void *, long *, arg_type_info *); 43int 44umovelong (Process *proc, void *addr, long *result, arg_type_info *info) { 45 return arch_umovelong (proc, addr, result, info); 46} 47#else 48/* Read a single long from the process's memory address 'addr' */ 49int 50umovelong (Process *proc, void *addr, long *result, arg_type_info *info) { 51 long pointed_to; 52 53 errno = 0; 54 pointed_to = ptrace (PTRACE_PEEKTEXT, proc->pid, addr, 0); 55 if (pointed_to == -1 && errno) 56 return -errno; 57 58 *result = pointed_to; 59 if (info) { 60 switch(info->type) { 61 case ARGTYPE_INT: 62 *result &= 0x00000000ffffffffUL; 63 default: 64 break; 65 }; 66 } 67 return 0; 68} 69#endif 70 71void 72trace_me(void) { 73 debug(DEBUG_PROCESS, "trace_me: pid=%d", getpid()); 74 if (ptrace(PTRACE_TRACEME, 0, 1, 0) < 0) { 75 perror("PTRACE_TRACEME"); 76 exit(1); 77 } 78} 79 80int 81trace_pid(pid_t pid) { 82 debug(DEBUG_PROCESS, "trace_pid: pid=%d", pid); 83 if (ptrace(PTRACE_ATTACH, pid, 1, 0) < 0) { 84 return -1; 85 } 86 87 /* man ptrace: PTRACE_ATTACH attaches to the process specified 88 in pid. The child is sent a SIGSTOP, but will not 89 necessarily have stopped by the completion of this call; 90 use wait() to wait for the child to stop. */ 91 if (waitpid (pid, NULL, __WALL) != pid) { 92 perror ("trace_pid: waitpid"); 93 return -1; 94 } 95 96 return 0; 97} 98 99void 100trace_set_options(Process *proc, pid_t pid) { 101 if (proc->tracesysgood & 0x80) 102 return; 103 104 debug(DEBUG_PROCESS, "trace_set_options: pid=%d", pid); 105 106 long options = PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEFORK | 107 PTRACE_O_TRACEVFORK | PTRACE_O_TRACECLONE | 108 PTRACE_O_TRACEEXEC; 109 if (ptrace(PTRACE_SETOPTIONS, pid, 0, options) < 0 && 110 ptrace(PTRACE_OLDSETOPTIONS, pid, 0, options) < 0) { 111 perror("PTRACE_SETOPTIONS"); 112 return; 113 } 114 proc->tracesysgood |= 0x80; 115} 116 117void 118untrace_pid(pid_t pid) { 119 debug(DEBUG_PROCESS, "untrace_pid: pid=%d", pid); 120 ptrace(PTRACE_DETACH, pid, 1, 0); 121} 122 123void 124continue_after_signal(pid_t pid, int signum) { 125 Process *proc; 126 127 debug(DEBUG_PROCESS, "continue_after_signal: pid=%d, signum=%d", pid, signum); 128 129 proc = pid2proc(pid); 130 ptrace(PTRACE_SYSCALL, pid, 0, signum); 131} 132 133static enum ecb_status 134event_for_pid(Event * event, void * data) 135{ 136 if (event->proc != NULL && event->proc->pid == (pid_t)(uintptr_t)data) 137 return ecb_yield; 138 return ecb_cont; 139} 140 141static int 142have_events_for(pid_t pid) 143{ 144 return each_qd_event(event_for_pid, (void *)(uintptr_t)pid) != NULL; 145} 146 147void 148continue_process(pid_t pid) 149{ 150 debug(DEBUG_PROCESS, "continue_process: pid=%d", pid); 151 152 /* Only really continue the process if there are no events in 153 the queue for this process. Otherwise just for the other 154 events to arrive. */ 155 if (!have_events_for(pid)) 156 /* We always trace syscalls to control fork(), 157 * clone(), execve()... */ 158 ptrace(PTRACE_SYSCALL, pid, 0, 0); 159 else 160 debug(DEBUG_PROCESS, 161 "putting off the continue, events in que."); 162} 163 164/** 165 * This is used for bookkeeping related to PIDs that the event 166 * handlers work with. 167 */ 168struct pid_task { 169 pid_t pid; /* This may be 0 for tasks that exited 170 * mid-handling. */ 171 int sigstopped; 172 int got_event; 173 int delivered; 174} * pids; 175 176struct pid_set { 177 struct pid_task * tasks; 178 size_t count; 179 size_t alloc; 180}; 181 182/** 183 * Breakpoint re-enablement. When we hit a breakpoint, we must 184 * disable it, single-step, and re-enable it. That single-step can be 185 * done only by one task in a task group, while others are stopped, 186 * otherwise the processes would race for who sees the breakpoint 187 * disabled and who doesn't. The following is to keep track of it 188 * all. 189 */ 190struct process_stopping_handler 191{ 192 Event_Handler super; 193 194 /* The task that is doing the re-enablement. */ 195 Process * task_enabling_breakpoint; 196 197 /* The pointer being re-enabled. */ 198 Breakpoint * breakpoint_being_enabled; 199 200 enum { 201 /* We are waiting for everyone to land in t/T. */ 202 psh_stopping = 0, 203 204 /* We are doing the PTRACE_SINGLESTEP. */ 205 psh_singlestep, 206 207 /* We are waiting for all the SIGSTOPs to arrive so 208 * that we can sink them. */ 209 psh_sinking, 210 211 /* This is for tracking the ugly workaround. */ 212 psh_ugly_workaround, 213 } state; 214 215 struct pid_set pids; 216}; 217 218static enum pcb_status 219task_stopped(Process * task, void * data) 220{ 221 /* If the task is already stopped, don't worry about it. 222 * Likewise if it managed to become a zombie or terminate in 223 * the meantime. This can happen when the whole thread group 224 * is terminating. */ 225 switch (process_status(task->pid)) { 226 case ps_invalid: 227 case ps_tracing_stop: 228 case ps_zombie: 229 return pcb_cont; 230 default: 231 return pcb_stop; 232 } 233} 234 235static struct pid_task * 236get_task_info(struct pid_set * pids, pid_t pid) 237{ 238 assert(pid != 0); 239 size_t i; 240 for (i = 0; i < pids->count; ++i) 241 if (pids->tasks[i].pid == pid) 242 return &pids->tasks[i]; 243 244 return NULL; 245} 246 247static struct pid_task * 248add_task_info(struct pid_set * pids, pid_t pid) 249{ 250 if (pids->count == pids->alloc) { 251 size_t ns = (2 * pids->alloc) ?: 4; 252 struct pid_task * n = realloc(pids->tasks, 253 sizeof(*pids->tasks) * ns); 254 if (n == NULL) 255 return NULL; 256 pids->tasks = n; 257 pids->alloc = ns; 258 } 259 struct pid_task * task_info = &pids->tasks[pids->count++]; 260 memset(task_info, 0, sizeof(*task_info)); 261 task_info->pid = pid; 262 return task_info; 263} 264 265static enum pcb_status 266send_sigstop(Process * task, void * data) 267{ 268 Process * leader = task->leader; 269 struct pid_set * pids = data; 270 271 /* Look for pre-existing task record, or add new. */ 272 struct pid_task * task_info = get_task_info(pids, task->pid); 273 if (task_info == NULL) 274 task_info = add_task_info(pids, task->pid); 275 if (task_info == NULL) { 276 perror("send_sigstop: add_task_info"); 277 destroy_event_handler(leader); 278 /* Signal failure upwards. */ 279 return pcb_stop; 280 } 281 282 /* This task still has not been attached to. It should be 283 stopped by the kernel. */ 284 if (task->state == STATE_BEING_CREATED) 285 return pcb_cont; 286 287 /* Don't bother sending SIGSTOP if we are already stopped, or 288 * if we sent the SIGSTOP already, which happens when we 289 * inherit the handler from breakpoint re-enablement. */ 290 if (task_stopped(task, NULL) == pcb_cont) 291 return pcb_cont; 292 if (task_info->sigstopped) { 293 if (!task_info->delivered) 294 return pcb_cont; 295 task_info->delivered = 0; 296 } 297 298 if (task_kill(task->pid, SIGSTOP) >= 0) { 299 debug(DEBUG_PROCESS, "send SIGSTOP to %d", task->pid); 300 task_info->sigstopped = 1; 301 } else 302 fprintf(stderr, 303 "Warning: couldn't send SIGSTOP to %d\n", task->pid); 304 305 return pcb_cont; 306} 307 308static void 309process_stopping_done(struct process_stopping_handler * self, Process * leader) 310{ 311 debug(DEBUG_PROCESS, "process stopping done %d", 312 self->task_enabling_breakpoint->pid); 313 size_t i; 314 for (i = 0; i < self->pids.count; ++i) 315 if (self->pids.tasks[i].pid != 0 316 && self->pids.tasks[i].delivered) 317 continue_process(self->pids.tasks[i].pid); 318 continue_process(self->task_enabling_breakpoint->pid); 319 destroy_event_handler(leader); 320} 321 322static void 323handle_stopping_event(struct pid_task * task_info, Event ** eventp) 324{ 325 /* Mark all events, so that we know whom to SIGCONT later. */ 326 if (task_info != NULL) 327 task_info->got_event = 1; 328 329 Event * event = *eventp; 330 331 /* In every state, sink SIGSTOP events for tasks that it was 332 * sent to. */ 333 if (task_info != NULL 334 && event->type == EVENT_SIGNAL 335 && event->e_un.signum == SIGSTOP) { 336 debug(DEBUG_PROCESS, "SIGSTOP delivered to %d", task_info->pid); 337 if (task_info->sigstopped 338 && !task_info->delivered) { 339 task_info->delivered = 1; 340 *eventp = NULL; // sink the event 341 } else 342 fprintf(stderr, "suspicious: %d got SIGSTOP, but " 343 "sigstopped=%d and delivered=%d\n", 344 task_info->pid, task_info->sigstopped, 345 task_info->delivered); 346 } 347} 348 349/* Some SIGSTOPs may have not been delivered to their respective tasks 350 * yet. They are still in the queue. If we have seen an event for 351 * that process, continue it, so that the SIGSTOP can be delivered and 352 * caught by ltrace. */ 353static void 354continue_for_sigstop_delivery(struct pid_set * pids) 355{ 356 size_t i; 357 for (i = 0; i < pids->count; ++i) { 358 if (pids->tasks[i].pid != 0 359 && pids->tasks[i].sigstopped 360 && !pids->tasks[i].delivered 361 && pids->tasks[i].got_event) { 362 debug(DEBUG_PROCESS, "continue %d for SIGSTOP delivery", 363 pids->tasks[i].pid); 364 ptrace(PTRACE_SYSCALL, pids->tasks[i].pid, 0, 0); 365 } 366 } 367} 368 369static int 370event_exit_p(Event * event) 371{ 372 return event != NULL && (event->type == EVENT_EXIT 373 || event->type == EVENT_EXIT_SIGNAL); 374} 375 376static int 377event_exit_or_none_p(Event * event) 378{ 379 return event == NULL || event_exit_p(event) 380 || event->type == EVENT_NONE; 381} 382 383static int 384await_sigstop_delivery(struct pid_set * pids, struct pid_task * task_info, 385 Event * event) 386{ 387 /* If we still didn't get our SIGSTOP, continue the process 388 * and carry on. */ 389 if (event != NULL && !event_exit_or_none_p(event) 390 && task_info != NULL && task_info->sigstopped) { 391 debug(DEBUG_PROCESS, "continue %d for SIGSTOP delivery", 392 task_info->pid); 393 /* We should get the signal the first thing 394 * after this, so it should be OK to continue 395 * even if we are over a breakpoint. */ 396 ptrace(PTRACE_SYSCALL, task_info->pid, 0, 0); 397 398 } else { 399 /* If all SIGSTOPs were delivered, uninstall the 400 * handler and continue everyone. */ 401 /* XXX I suspect that we should check tasks that are 402 * still around. Is things are now, there should be a 403 * race between waiting for everyone to stop and one 404 * of the tasks exiting. */ 405 int all_clear = 1; 406 size_t i; 407 for (i = 0; i < pids->count; ++i) 408 if (pids->tasks[i].pid != 0 409 && pids->tasks[i].sigstopped 410 && !pids->tasks[i].delivered) { 411 all_clear = 0; 412 break; 413 } 414 return all_clear; 415 } 416 417 return 0; 418} 419 420/* This event handler is installed when we are in the process of 421 * stopping the whole thread group to do the pointer re-enablement for 422 * one of the threads. We pump all events to the queue for later 423 * processing while we wait for all the threads to stop. When this 424 * happens, we let the re-enablement thread to PTRACE_SINGLESTEP, 425 * re-enable, and continue everyone. */ 426static Event * 427process_stopping_on_event(Event_Handler * super, Event * event) 428{ 429 struct process_stopping_handler * self = (void *)super; 430 Process * task = event->proc; 431 Process * leader = task->leader; 432 Breakpoint * sbp = self->breakpoint_being_enabled; 433 Process * teb = self->task_enabling_breakpoint; 434 435 debug(DEBUG_PROCESS, 436 "pid %d; event type %d; state %d", 437 task->pid, event->type, self->state); 438 439 struct pid_task * task_info = get_task_info(&self->pids, task->pid); 440 if (task_info == NULL) 441 fprintf(stderr, "new task??? %d\n", task->pid); 442 handle_stopping_event(task_info, &event); 443 444 int state = self->state; 445 int event_to_queue = !event_exit_or_none_p(event); 446 447 /* Deactivate the entry if the task exits. */ 448 if (event_exit_p(event) && task_info != NULL) 449 task_info->pid = 0; 450 451 switch (state) { 452 case psh_stopping: 453 /* If everyone is stopped, singlestep. */ 454 if (each_task(leader, &task_stopped, NULL) == NULL) { 455 debug(DEBUG_PROCESS, "all stopped, now SINGLESTEP %d", 456 teb->pid); 457 if (sbp->enabled) 458 disable_breakpoint(teb, sbp); 459 if (ptrace(PTRACE_SINGLESTEP, teb->pid, 0, 0)) 460 perror("PTRACE_SINGLESTEP"); 461 self->state = state = psh_singlestep; 462 } 463 break; 464 465 case psh_singlestep: { 466 /* In singlestep state, breakpoint signifies that we 467 * have now stepped, and can re-enable the breakpoint. */ 468 if (event != NULL && task == teb) { 469 /* Essentially we don't care what event caused 470 * the thread to stop. We can do the 471 * re-enablement now. */ 472 enable_breakpoint(teb, sbp); 473 474 continue_for_sigstop_delivery(&self->pids); 475 476 self->breakpoint_being_enabled = NULL; 477 self->state = state = psh_sinking; 478 479 if (event->type == EVENT_BREAKPOINT) 480 event = NULL; // handled 481 } else 482 break; 483 } 484 485 /* fall-through */ 486 487 case psh_sinking: 488 if (await_sigstop_delivery(&self->pids, task_info, event)) 489 process_stopping_done(self, leader); 490 } 491 492 if (event != NULL && event_to_queue) { 493 enque_event(event); 494 event = NULL; // sink the event 495 } 496 497 return event; 498} 499 500static void 501process_stopping_destroy(Event_Handler * super) 502{ 503 struct process_stopping_handler * self = (void *)super; 504 if (self->breakpoint_being_enabled != NULL) 505 enable_breakpoint(self->task_enabling_breakpoint, 506 self->breakpoint_being_enabled); 507 free(self->pids.tasks); 508} 509 510void 511continue_after_breakpoint(Process *proc, Breakpoint *sbp) 512{ 513 set_instruction_pointer(proc, sbp->addr); 514 if (sbp->enabled == 0) { 515 if (sbp->enabled) 516 disable_breakpoint(proc, sbp); 517 continue_process(proc->pid); 518 } else { 519 debug(DEBUG_PROCESS, 520 "continue_after_breakpoint: pid=%d, addr=%p", 521 proc->pid, sbp->addr); 522#if defined __sparc__ || defined __ia64___ || defined __mips__ 523 /* we don't want to singlestep here */ 524 continue_process(proc->pid); 525#else 526 struct process_stopping_handler * handler 527 = calloc(sizeof(*handler), 1); 528 if (handler == NULL) { 529 perror("malloc breakpoint disable handler"); 530 fatal: 531 /* Carry on not bothering to re-enable. */ 532 continue_process(proc->pid); 533 return; 534 } 535 536 handler->super.on_event = process_stopping_on_event; 537 handler->super.destroy = process_stopping_destroy; 538 handler->task_enabling_breakpoint = proc; 539 handler->breakpoint_being_enabled = sbp; 540 install_event_handler(proc->leader, &handler->super); 541 542 if (each_task(proc->leader, &send_sigstop, 543 &handler->pids) != NULL) 544 goto fatal; 545 546 /* And deliver the first fake event, in case all the 547 * conditions are already fulfilled. */ 548 Event ev; 549 ev.type = EVENT_NONE; 550 ev.proc = proc; 551 process_stopping_on_event(&handler->super, &ev); 552#endif 553 } 554} 555 556/** 557 * Ltrace exit. When we are about to exit, we have to go through all 558 * the processes, stop them all, remove all the breakpoints, and then 559 * detach the processes that we attached to using -p. If we left the 560 * other tasks running, they might hit stray return breakpoints and 561 * produce artifacts, so we better stop everyone, even if it's a bit 562 * of extra work. 563 */ 564struct ltrace_exiting_handler 565{ 566 Event_Handler super; 567 struct pid_set pids; 568 int state; 569 Process * task_enabling_breakpoint; 570}; 571 572static enum pcb_status 573remove_task(Process * task, void * data) 574{ 575 /* Don't untrace leader just yet. */ 576 if (task != data) 577 remove_process(task); 578 return pcb_cont; 579} 580 581static enum pcb_status 582untrace_task(Process * task, void * data) 583{ 584 untrace_pid(task->pid); 585 return pcb_cont; 586} 587 588/* Before we detach, we need to make sure that task's IP is on the 589 * edge of an instruction. So for tasks that have a breakpoint event 590 * in the queue, we adjust the instruction pointer, just like 591 * continue_after_breakpoint does. */ 592static enum ecb_status 593undo_breakpoint(Event * event, void * data) 594{ 595 if (event != NULL 596 && event->proc->leader == data 597 && event->type == EVENT_BREAKPOINT) { 598 fprintf(stderr, " + %p ", get_instruction_pointer(event->proc)); 599 set_instruction_pointer(event->proc, event->e_un.brk_addr); 600 fprintf(stderr, "-> %p\n", get_instruction_pointer(event->proc)); 601 } 602 return ecb_cont; 603} 604 605static void 606ugly_workaround(Process * proc, int cont) 607{ 608 void * ip = get_instruction_pointer(proc); 609 fprintf(stderr, "activate workaround %d %p\n", proc->pid, ip); 610 Breakpoint * sbp = dict_find_entry(proc->leader->breakpoints, ip); 611 if (sbp != NULL) 612 enable_breakpoint(proc, sbp); 613 else 614 insert_breakpoint(proc, ip, NULL, 1); 615 if (cont) 616 ptrace(PTRACE_CONT, proc->pid, 0, 0); 617} 618 619static int 620all_stops_accountable(struct pid_set * pids) 621{ 622 size_t i; 623 for (i = 0; i < pids->count; ++i) 624 if (pids->tasks[i].pid != 0 625 && !pids->tasks[i].got_event 626 && !have_events_for(pids->tasks[i].pid)) 627 return 0; 628 return 1; 629} 630 631static Event * 632ltrace_exiting_on_event(Event_Handler * super, Event * event) 633{ 634 struct ltrace_exiting_handler * self = (void *)super; 635 Process * task = event->proc; 636 Process * leader = task->leader; 637 638 debug(DEBUG_PROCESS, "pid %d; event type %d", task->pid, event->type); 639 640 struct pid_task * task_info = get_task_info(&self->pids, task->pid); 641 handle_stopping_event(task_info, &event); 642 643 if (event != NULL && event->type == EVENT_BREAKPOINT) { 644 if (self->state == psh_singlestep 645 && self->task_enabling_breakpoint == event->proc) { 646 ugly_workaround(event->proc, 1); 647 self->state = psh_ugly_workaround; 648 } else { 649 undo_breakpoint(event, leader); 650 if (self->state == psh_ugly_workaround 651 && self->task_enabling_breakpoint == event->proc) { 652 self->task_enabling_breakpoint = NULL; 653 self->state = psh_sinking; 654 } 655 } 656 } 657 658 if (await_sigstop_delivery(&self->pids, task_info, event) 659 && (self->task_enabling_breakpoint == NULL 660 /* NB: psh_ugly_workaround > psh_singlestep */ 661 || self->state < psh_singlestep) 662 && all_stops_accountable(&self->pids)) { 663 debug(DEBUG_PROCESS, "all SIGSTOPs delivered %d", leader->pid); 664 each_qd_event(&undo_breakpoint, leader); 665 disable_all_breakpoints(leader); 666 667 /* Now untrace the process, if it was attached to by -p. */ 668 struct opt_p_t * it; 669 for (it = opt_p; it != NULL; it = it->next) { 670 Process * proc = pid2proc(it->pid); 671 if (proc == NULL) 672 continue; 673 if (proc->leader == leader) { 674 each_task(leader, &untrace_task, NULL); 675 break; 676 } 677 } 678 679 each_task(leader, &remove_task, leader); 680 destroy_event_handler(leader); 681 remove_task(leader, NULL); 682 return NULL; 683 } 684 685 /* Sink all non-exit events. We are about to exit, so we 686 * don't bother with queuing them. */ 687 if (event_exit_or_none_p(event)) 688 return event; 689 690 return NULL; 691} 692 693static void 694ltrace_exiting_destroy(Event_Handler * super) 695{ 696 struct ltrace_exiting_handler * self = (void *)super; 697 free(self->pids.tasks); 698} 699 700static int 701ltrace_exiting_install_handler(Process * proc) 702{ 703 /* Only install to leader. */ 704 if (proc->leader != proc) 705 return 0; 706 707 /* Perhaps we are already installed, if the user passed 708 * several -p options that are tasks of one process. */ 709 if (proc->event_handler != NULL 710 && proc->event_handler->on_event == <race_exiting_on_event) 711 return 0; 712 713 struct ltrace_exiting_handler * handler 714 = calloc(sizeof(*handler), 1); 715 if (handler == NULL) { 716 perror("malloc exiting handler"); 717 fatal: 718 /* XXXXXXXXXXXXXXXXXXX fixme */ 719 return -1; 720 } 721 722 /* If we are in the middle of breakpoint, extract the 723 * pid-state information from that handler so that we can take 724 * over the SIGSTOP handling. */ 725 if (proc->event_handler != NULL) { 726 debug(DEBUG_PROCESS, "taking over breakpoint handling"); 727 assert(proc->event_handler->on_event 728 == &process_stopping_on_event); 729 struct process_stopping_handler * other 730 = (void *)proc->event_handler; 731 732 handler->task_enabling_breakpoint 733 = other->task_enabling_breakpoint; 734 if (other->state == psh_sinking) { 735 ugly_workaround(handler->task_enabling_breakpoint, 1); 736 handler->state = psh_ugly_workaround; 737 } else { 738 handler->state = other->state; 739 } 740 741 size_t i; 742 for (i = 0; i < other->pids.count; ++i) { 743 struct pid_task * oti = &other->pids.tasks[i]; 744 if (oti->pid == 0) 745 continue; 746 747 struct pid_task * task_info 748 = add_task_info(&handler->pids, oti->pid); 749 if (task_info == NULL) { 750 perror("ltrace_exiting_install_handler" 751 ":add_task_info"); 752 goto fatal; 753 } 754 /* Copy over the state. */ 755 *task_info = *oti; 756 } 757 758 /* The re-enablement handler sets this to NULL when 759 * it calls continue_for_sigstop_delivery. */ 760 if (other->breakpoint_being_enabled != NULL) 761 continue_for_sigstop_delivery(&handler->pids); 762 763 /* And destroy the original handler. */ 764 destroy_event_handler(proc); 765 } 766 767 handler->super.on_event = ltrace_exiting_on_event; 768 handler->super.destroy = ltrace_exiting_destroy; 769 install_event_handler(proc->leader, &handler->super); 770 771 if (each_task(proc->leader, &send_sigstop, 772 &handler->pids) != NULL) 773 goto fatal; 774 775 return 0; 776} 777 778/* If ltrace gets SIGINT, the processes directly or indirectly run by 779 * ltrace get it too. We just have to wait long enough for the signal 780 * to be delivered and the process terminated, which we notice and 781 * exit ltrace, too. So there's not much we need to do there. We 782 * want to keep tracing those processes as usual, in case they just 783 * SIG_IGN the SIGINT to do their shutdown etc. 784 * 785 * For processes ran on the background, we want to install an exit 786 * handler that stops all the threads, removes all breakpoints, and 787 * detaches. 788 */ 789void 790ltrace_exiting(void) 791{ 792 struct opt_p_t * it; 793 for (it = opt_p; it != NULL; it = it->next) { 794 Process * proc = pid2proc(it->pid); 795 if (proc == NULL || proc->leader == NULL) 796 continue; 797 if (ltrace_exiting_install_handler(proc->leader) < 0) 798 fprintf(stderr, 799 "Couldn't install exiting handler for %d.\n", 800 proc->pid); 801 } 802} 803 804size_t 805umovebytes(Process *proc, void *addr, void *laddr, size_t len) { 806 807 union { 808 long a; 809 char c[sizeof(long)]; 810 } a; 811 int started = 0; 812 size_t offset = 0, bytes_read = 0; 813 814 while (offset < len) { 815 a.a = ptrace(PTRACE_PEEKTEXT, proc->pid, addr + offset, 0); 816 if (a.a == -1 && errno) { 817 if (started && errno == EIO) 818 return bytes_read; 819 else 820 return -1; 821 } 822 started = 1; 823 824 if (len - offset >= sizeof(long)) { 825 memcpy(laddr + offset, &a.c[0], sizeof(long)); 826 bytes_read += sizeof(long); 827 } 828 else { 829 memcpy(laddr + offset, &a.c[0], len - offset); 830 bytes_read += (len - offset); 831 } 832 offset += sizeof(long); 833 } 834 835 return bytes_read; 836} 837 838/* Read a series of bytes starting at the process's memory address 839 'addr' and continuing until a NUL ('\0') is seen or 'len' bytes 840 have been read. 841*/ 842int 843umovestr(Process *proc, void *addr, int len, void *laddr) { 844 union { 845 long a; 846 char c[sizeof(long)]; 847 } a; 848 unsigned i; 849 int offset = 0; 850 851 while (offset < len) { 852 a.a = ptrace(PTRACE_PEEKTEXT, proc->pid, addr + offset, 0); 853 for (i = 0; i < sizeof(long); i++) { 854 if (a.c[i] && offset + (signed)i < len) { 855 *(char *)(laddr + offset + i) = a.c[i]; 856 } else { 857 *(char *)(laddr + offset + i) = '\0'; 858 return 0; 859 } 860 } 861 offset += sizeof(long); 862 } 863 *(char *)(laddr + offset) = '\0'; 864 return 0; 865} 866