trace.c revision 98f0992f9c3fd5da41a4928407251d9f5a837702
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 //printf("continue_process %d\n", pid); 152 153 /* Only really continue the process if there are no events in 154 the queue for this process. Otherwise just for the other 155 events to arrive. */ 156 if (!have_events_for(pid)) 157 /* We always trace syscalls to control fork(), 158 * clone(), execve()... */ 159 ptrace(PTRACE_SYSCALL, pid, 0, 0); 160 else 161 debug(DEBUG_PROCESS, 162 "putting off the continue, events in que."); 163} 164 165/** 166 * This is used for bookkeeping related to PIDs that the event 167 * handlers work with. */ 168struct pid_task { 169 pid_t pid; 170 int sigstopped; 171 int got_event; 172 int delivered; 173} * pids; 174 175struct pid_set { 176 struct pid_task * tasks; 177 size_t count; 178 size_t alloc; 179}; 180 181/** 182 * Breakpoint re-enablement. When we hit a breakpoint, we must 183 * disable it, single-step, and re-enable it. That single-step can be 184 * done only by one task in a task group, while others are stopped, 185 * otherwise the processes would race for who sees the breakpoint 186 * disabled and who doesn't. The following is to keep track of it 187 * all. 188 */ 189struct process_stopping_handler 190{ 191 Event_Handler super; 192 193 /* The task that is doing the re-enablement. */ 194 Process * task_enabling_breakpoint; 195 196 /* The pointer being re-enabled. */ 197 Breakpoint * breakpoint_being_enabled; 198 199 enum { 200 /* We are waiting for everyone to land in t/T. */ 201 psh_stopping = 0, 202 203 /* We are doing the PTRACE_SINGLESTEP. */ 204 psh_singlestep, 205 206 /* We are waiting for all the SIGSTOPs to arrive so 207 * that we can sink them. */ 208 psh_sinking, 209 } state; 210 211 struct pid_set pids; 212}; 213 214static enum pcb_status 215task_stopped(Process * task, void * data) 216{ 217 int status; 218 219 /* If the task is already stopped, don't worry about it. 220 * Likewise if it managed to become a zombie or terminate in 221 * the meantime. This can happen when the whole thread group 222 * is terminating. */ 223 switch (status = process_status(task->pid)) 224 case -1: 225 case 't': 226 case 'Z': 227 return pcb_cont; 228 229 return pcb_stop; 230} 231 232static struct pid_task * 233get_task_info(struct pid_set * pids, pid_t pid) 234{ 235 size_t i; 236 for (i = 0; i < pids->count; ++i) 237 if (pids->tasks[i].pid == pid) 238 return &pids->tasks[i]; 239 240 return NULL; 241} 242 243static struct pid_task * 244add_task_info(struct pid_set * pids, pid_t pid) 245{ 246 if (pids->count == pids->alloc) { 247 size_t ns = (2 * pids->alloc) ?: 4; 248 struct pid_task * n = realloc(pids->tasks, 249 sizeof(*pids->tasks) * ns); 250 if (n == NULL) 251 return NULL; 252 pids->tasks = n; 253 pids->alloc = ns; 254 } 255 struct pid_task * task_info = &pids->tasks[pids->count++]; 256 memset(task_info, 0, sizeof(*task_info)); 257 task_info->pid = pid; 258 return task_info; 259} 260 261static enum pcb_status 262send_sigstop(Process * task, void * data) 263{ 264 Process * leader = task->leader; 265 struct pid_set * pids = data; 266 267 /* Look for pre-existing task record, or add new. */ 268 struct pid_task * task_info = get_task_info(pids, task->pid); 269 if (task_info == NULL) 270 task_info = add_task_info(pids, task->pid); 271 if (task_info == NULL) { 272 perror("send_sigstop: add_task_info"); 273 destroy_event_handler(leader); 274 /* Signal failure upwards. */ 275 return pcb_stop; 276 } 277 278 /* This task still has not been attached to. It should be 279 stopped by the kernel. */ 280 if (task->state == STATE_BEING_CREATED) 281 return pcb_cont; 282 283 /* Don't bother sending SIGSTOP if we are already stopped, or 284 * if we sent the SIGSTOP already, which happens when we 285 * inherit the handler from breakpoint re-enablement. */ 286 if (task_stopped(task, NULL) == pcb_cont) 287 return pcb_cont; 288 if (task_info->sigstopped) { 289 if (!task_info->delivered) 290 return pcb_cont; 291 task_info->delivered = 0; 292 } 293 294 if (task_kill(task->pid, SIGSTOP) >= 0) { 295 debug(DEBUG_PROCESS, "send SIGSTOP to %d", task->pid); 296 task_info->sigstopped = 1; 297 } else 298 fprintf(stderr, 299 "Warning: couldn't send SIGSTOP to %d\n", task->pid); 300 301 return pcb_cont; 302} 303 304static void 305process_stopping_done(struct process_stopping_handler * self, Process * leader) 306{ 307 debug(DEBUG_PROCESS, "process stopping done %d", 308 self->task_enabling_breakpoint->pid); 309 size_t i; 310 for (i = 0; i < self->pids.count; ++i) 311 if (self->pids.tasks[i].delivered) 312 continue_process(self->pids.tasks[i].pid); 313 continue_process(self->task_enabling_breakpoint->pid); 314 destroy_event_handler(leader); 315} 316 317static void 318handle_stopping_event(struct pid_task * task_info, Event ** eventp) 319{ 320 /* Mark all events, so that we know whom to SIGCONT later. */ 321 if (task_info != NULL && task_info->sigstopped) 322 task_info->got_event = 1; 323 324 Event * event = *eventp; 325 326 /* In every state, sink SIGSTOP events for tasks that it was 327 * sent to. */ 328 if (task_info != NULL 329 && event->type == EVENT_SIGNAL 330 && event->e_un.signum == SIGSTOP) { 331 debug(DEBUG_PROCESS, "SIGSTOP delivered to %d", task_info->pid); 332 if (task_info->sigstopped 333 && !task_info->delivered) { 334 task_info->delivered = 1; 335 *eventp = NULL; // sink the event 336 } else 337 fprintf(stderr, "suspicious: %d got SIGSTOP, but " 338 "sigstopped=%d and delivered=%d\n", 339 task_info->pid, task_info->sigstopped, 340 task_info->delivered); 341 } 342} 343 344/* Some SIGSTOPs may have not been delivered to their respective tasks 345 * yet. They are still in the queue. If we have seen an event for 346 * that process, continue it, so that the SIGSTOP can be delivered and 347 * caught by ltrace. */ 348static void 349continue_for_sigstop_delivery(struct pid_set * pids) 350{ 351 size_t i; 352 for (i = 0; i < pids->count; ++i) { 353 if (pids->tasks[i].sigstopped 354 && !pids->tasks[i].delivered 355 && pids->tasks[i].got_event) { 356 debug(DEBUG_PROCESS, "continue %d for SIGSTOP delivery", 357 pids->tasks[i].pid); 358 ptrace(PTRACE_SYSCALL, pids->tasks[i].pid, 0, 0); 359 } 360 } 361} 362 363static int 364event_exit_or_none_p(Event * event) 365{ 366 return event == NULL 367 || event->type == EVENT_EXIT 368 || event->type == EVENT_EXIT_SIGNAL 369 || event->type == EVENT_NONE; 370} 371 372static int 373await_sigstop_delivery(struct pid_set * pids, struct pid_task * task_info, 374 Event * event) 375{ 376 /* If we still didn't get our SIGSTOP, continue the process 377 * and carry on. */ 378 if (event != NULL && !event_exit_or_none_p(event) 379 && task_info != NULL && task_info->sigstopped) { 380 debug(DEBUG_PROCESS, "continue %d for SIGSTOP delivery", 381 task_info->pid); 382 /* We should get the signal the first thing 383 * after this, so it should be OK to continue 384 * even if we are over a breakpoint. */ 385 ptrace(PTRACE_SYSCALL, task_info->pid, 0, 0); 386 387 } else { 388 /* If all SIGSTOPs were delivered, uninstall the 389 * handler and continue everyone. */ 390 /* XXX I suspect that we should check tasks that are 391 * still around. Is things are now, there should be a 392 * race between waiting for everyone to stop and one 393 * of the tasks exiting. */ 394 int all_clear = 1; 395 size_t i; 396 for (i = 0; i < pids->count; ++i) 397 if (pids->tasks[i].sigstopped 398 && !pids->tasks[i].delivered) { 399 all_clear = 0; 400 break; 401 } 402 return all_clear; 403 } 404 405 return 0; 406} 407 408/* This event handler is installed when we are in the process of 409 * stopping the whole thread group to do the pointer re-enablement for 410 * one of the threads. We pump all events to the queue for later 411 * processing while we wait for all the threads to stop. When this 412 * happens, we let the re-enablement thread to PTRACE_SINGLESTEP, 413 * re-enable, and continue everyone. */ 414static Event * 415process_stopping_on_event(Event_Handler * super, Event * event) 416{ 417 struct process_stopping_handler * self = (void *)super; 418 Process * task = event->proc; 419 Process * leader = task->leader; 420 421 debug(DEBUG_PROCESS, 422 "pid %d; event type %d; state %d", 423 task->pid, event->type, self->state); 424 425 struct pid_task * task_info = get_task_info(&self->pids, task->pid); 426 if (task_info == NULL) 427 fprintf(stderr, "new task??? %d\n", task->pid); 428 handle_stopping_event(task_info, &event); 429 430 int state = self->state; 431 int event_to_queue = !event_exit_or_none_p(event); 432 433 switch (state) { 434 case psh_stopping: 435 /* If everyone is stopped, singlestep. */ 436 if (each_task(leader, &task_stopped, NULL) == NULL) { 437 debug(DEBUG_PROCESS, "all stopped, now SINGLESTEP %d", 438 self->task_enabling_breakpoint->pid); 439 ptrace(PTRACE_SINGLESTEP, 440 self->task_enabling_breakpoint->pid, 0, 0); 441 self->state = state = psh_singlestep; 442 } 443 break; 444 445 case psh_singlestep: { 446 /* In singlestep state, breakpoint signifies that we 447 * have now stepped, and can re-enable the breakpoint. */ 448 if (event != NULL 449 && task == self->task_enabling_breakpoint) { 450 /* Essentially we don't care what event caused 451 * the thread to stop. We can do the 452 * re-enablement now. */ 453 enable_breakpoint(self->task_enabling_breakpoint, 454 self->breakpoint_being_enabled); 455 456 continue_for_sigstop_delivery(&self->pids); 457 458 self->breakpoint_being_enabled = NULL; 459 self->state = state = psh_sinking; 460 461 if (event->type == EVENT_BREAKPOINT) 462 event = NULL; // handled 463 } else 464 break; 465 } 466 467 /* fall-through */ 468 469 case psh_sinking: 470 if (await_sigstop_delivery(&self->pids, task_info, event)) 471 process_stopping_done(self, leader); 472 } 473 474 if (event != NULL && event_to_queue) { 475 enque_event(event); 476 event = NULL; // sink the event 477 } 478 479 return event; 480} 481 482static void 483process_stopping_destroy(Event_Handler * super) 484{ 485 struct process_stopping_handler * self = (void *)super; 486 if (self->breakpoint_being_enabled != NULL) 487 enable_breakpoint(self->task_enabling_breakpoint, 488 self->breakpoint_being_enabled); 489 free(self->pids.tasks); 490} 491 492void 493continue_after_breakpoint(Process *proc, Breakpoint *sbp) 494{ 495 if (sbp->enabled) 496 disable_breakpoint(proc, sbp); 497 498 set_instruction_pointer(proc, sbp->addr); 499 if (sbp->enabled == 0) { 500 continue_process(proc->pid); 501 } else { 502 debug(DEBUG_PROCESS, 503 "continue_after_breakpoint: pid=%d, addr=%p", 504 proc->pid, sbp->addr); 505#if defined __sparc__ || defined __ia64___ || defined __mips__ 506 /* we don't want to singlestep here */ 507 continue_process(proc->pid); 508#else 509 struct process_stopping_handler * handler 510 = calloc(sizeof(*handler), 1); 511 if (handler == NULL) { 512 perror("malloc breakpoint disable handler"); 513 fatal: 514 /* Carry on not bothering to re-enable. */ 515 continue_process(proc->pid); 516 return; 517 } 518 519 handler->super.on_event = process_stopping_on_event; 520 handler->super.destroy = process_stopping_destroy; 521 handler->task_enabling_breakpoint = proc; 522 handler->breakpoint_being_enabled = sbp; 523 install_event_handler(proc->leader, &handler->super); 524 525 if (each_task(proc->leader, &send_sigstop, 526 &handler->pids) != NULL) 527 goto fatal; 528 529 /* And deliver the first fake event, in case all the 530 * conditions are already fulfilled. */ 531 Event ev; 532 ev.type = EVENT_NONE; 533 ev.proc = proc; 534 process_stopping_on_event(&handler->super, &ev); 535#endif 536 } 537} 538 539size_t 540umovebytes(Process *proc, void *addr, void *laddr, size_t len) { 541 542 union { 543 long a; 544 char c[sizeof(long)]; 545 } a; 546 int started = 0; 547 size_t offset = 0, bytes_read = 0; 548 549 while (offset < len) { 550 a.a = ptrace(PTRACE_PEEKTEXT, proc->pid, addr + offset, 0); 551 if (a.a == -1 && errno) { 552 if (started && errno == EIO) 553 return bytes_read; 554 else 555 return -1; 556 } 557 started = 1; 558 559 if (len - offset >= sizeof(long)) { 560 memcpy(laddr + offset, &a.c[0], sizeof(long)); 561 bytes_read += sizeof(long); 562 } 563 else { 564 memcpy(laddr + offset, &a.c[0], len - offset); 565 bytes_read += (len - offset); 566 } 567 offset += sizeof(long); 568 } 569 570 return bytes_read; 571} 572 573/* Read a series of bytes starting at the process's memory address 574 'addr' and continuing until a NUL ('\0') is seen or 'len' bytes 575 have been read. 576*/ 577int 578umovestr(Process *proc, void *addr, int len, void *laddr) { 579 union { 580 long a; 581 char c[sizeof(long)]; 582 } a; 583 unsigned i; 584 int offset = 0; 585 586 while (offset < len) { 587 a.a = ptrace(PTRACE_PEEKTEXT, proc->pid, addr + offset, 0); 588 for (i = 0; i < sizeof(long); i++) { 589 if (a.c[i] && offset + (signed)i < len) { 590 *(char *)(laddr + offset + i) = a.c[i]; 591 } else { 592 *(char *)(laddr + offset + i) = '\0'; 593 return 0; 594 } 595 } 596 offset += sizeof(long); 597 } 598 *(char *)(laddr + offset) = '\0'; 599 return 0; 600} 601