diff options
Diffstat (limited to 'agent/system/GNU/Linux/tcf/context-linux.c')
| -rw-r--r-- | agent/system/GNU/Linux/tcf/context-linux.c | 1187 |
1 files changed, 1187 insertions, 0 deletions
diff --git a/agent/system/GNU/Linux/tcf/context-linux.c b/agent/system/GNU/Linux/tcf/context-linux.c new file mode 100644 index 00000000..41dcd183 --- /dev/null +++ b/agent/system/GNU/Linux/tcf/context-linux.c @@ -0,0 +1,1187 @@ +/******************************************************************************* + * Copyright (c) 2007, 2010 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Eclipse Distribution License v1.0 which accompany this distribution. + * The Eclipse Public License is available at + * http://www.eclipse.org/legal/epl-v10.html + * and the Eclipse Distribution License is available at + * http://www.eclipse.org/org/documents/edl-v10.php. + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ + +/* + * This module handles process/thread OS contexts and their state machine. + */ + +#include <tcf/config.h> + +#if defined(__linux__) + +#if ENABLE_DebugContext && !ENABLE_ContextProxy + +#include <stdlib.h> +#include <assert.h> +#include <errno.h> +#include <signal.h> +#include <sched.h> +#include <dirent.h> +#include <asm/unistd.h> +#include <sys/ptrace.h> +#include <linux/kdev_t.h> +#include <tcf/framework/context.h> +#include <tcf/framework/events.h> +#include <tcf/framework/errors.h> +#include <tcf/framework/trace.h> +#include <tcf/framework/myalloc.h> +#include <tcf/framework/waitpid.h> +#include <tcf/framework/signames.h> +#include <tcf/services/breakpoints.h> +#include <tcf/services/expressions.h> +#include <tcf/services/memorymap.h> +#include <tcf/services/runctrl.h> +#include <tcf/services/tcf_elf.h> +#include <system/GNU/Linux/tcf/regset.h> + +#if !defined(PTRACE_SETOPTIONS) +#define PTRACE_SETOPTIONS 0x4200 +#define PTRACE_GETEVENTMSG 0x4201 +#define PTRACE_GETSIGINFO 0x4202 +#define PTRACE_SETSIGINFO 0x4203 + +#define PTRACE_O_TRACESYSGOOD 0x00000001 +#define PTRACE_O_TRACEFORK 0x00000002 +#define PTRACE_O_TRACEVFORK 0x00000004 +#define PTRACE_O_TRACECLONE 0x00000008 +#define PTRACE_O_TRACEEXEC 0x00000010 +#define PTRACE_O_TRACEVFORKDONE 0x00000020 +#define PTRACE_O_TRACEEXIT 0x00000040 + +#define PTRACE_EVENT_FORK 1 +#define PTRACE_EVENT_VFORK 2 +#define PTRACE_EVENT_CLONE 3 +#define PTRACE_EVENT_EXEC 4 +#define PTRACE_EVENT_VFORK_DONE 5 +#define PTRACE_EVENT_EXIT 6 +#endif + +#define USE_PTRACE_SYSCALL 0 + +static const int PTRACE_FLAGS = +#if USE_PTRACE_SYSCALL + PTRACE_O_TRACESYSGOOD | +#endif + PTRACE_O_TRACECLONE | + PTRACE_O_TRACEEXEC | + PTRACE_O_TRACEFORK | + PTRACE_O_TRACEVFORK | + PTRACE_O_TRACEVFORKDONE | + PTRACE_O_TRACEEXIT; + +typedef struct ContextExtensionLinux { + pid_t pid; + ContextAttachCallBack * attach_callback; + void * attach_data; + int attach_children; + int ptrace_flags; + int ptrace_event; + int syscall_enter; + int syscall_exit; + int syscall_id; + ContextAddress syscall_pc; + ContextAddress loader_state; + int end_of_step; + REG_SET * regs; /* copy of context registers, updated when context stops */ + ErrorReport * regs_error; /* if not NULL, 'regs' is invalid */ + int regs_dirty; /* if not 0, 'regs' is modified and needs to be saved before context is continued */ + int pending_step; + int tkill_cnt; +} ContextExtensionLinux; + +static size_t context_extension_offset = 0; + +#define EXT(ctx) ((ContextExtensionLinux *)((char *)(ctx) + context_extension_offset)) + +#include <tcf/framework/pid-hash.h> + +static LINK pending_list = TCF_LIST_INIT(pending_list); +static LINK detach_list = TCF_LIST_INIT(detach_list); + +static MemoryErrorInfo mem_err_info; + +static const char * event_name(int event) { + switch (event) { + case 0: return "none"; + case PTRACE_EVENT_FORK: return "fork"; + case PTRACE_EVENT_VFORK: return "vfork"; + case PTRACE_EVENT_CLONE: return "clone"; + case PTRACE_EVENT_EXEC: return "exec"; + case PTRACE_EVENT_VFORK_DONE: return "vfork-done"; + case PTRACE_EVENT_EXIT: return "exit"; + } + trace(LOG_ALWAYS, "event_name(): unexpected event code %d", event); + return "unknown"; +} + +const char * context_suspend_reason(Context * ctx) { + static char reason[128]; + + if (EXT(ctx)->end_of_step) return REASON_STEP; + if (EXT(ctx)->ptrace_event != 0) { + assert(ctx->signal == SIGTRAP); + snprintf(reason, sizeof(reason), "Event: %s", event_name(EXT(ctx)->ptrace_event)); + return reason; + } + if (EXT(ctx)->syscall_enter) return "System Call"; + if (EXT(ctx)->syscall_exit) return "System Return"; + if (ctx->signal == SIGSTOP || ctx->signal == SIGTRAP) return REASON_USER_REQUEST; + snprintf(reason, sizeof(reason), "Signal %d", ctx->signal); + return reason; +} + +int context_attach_self(void) { + if (ptrace(PTRACE_TRACEME, 0, 0, 0) < 0) { + int err = errno; + trace(LOG_ALWAYS, "error: ptrace(PTRACE_TRACEME) failed: pid %d, error %d %s", + getpid(), err, errno_to_str(err)); + errno = err; + return -1; + } + return 0; +} + +int context_attach(pid_t pid, ContextAttachCallBack * done, void * data, int mode) { + Context * ctx = NULL; + ContextExtensionLinux * ext = NULL; + + assert(done != NULL); + trace(LOG_CONTEXT, "context: attaching pid %d", pid); + if ((mode & CONTEXT_ATTACH_SELF) == 0 && ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) { + int err = errno; + trace(LOG_ALWAYS, "error: ptrace(PTRACE_ATTACH) failed: pid %d, error %d %s", + pid, err, errno_to_str(err)); + errno = err; + return -1; + } + add_waitpid_process(pid); + ctx = create_context(pid2id(pid, 0)); + ctx->mem = ctx; + ctx->mem_access |= MEM_ACCESS_INSTRUCTION; + ctx->mem_access |= MEM_ACCESS_DATA; + ctx->mem_access |= MEM_ACCESS_USER; + ctx->big_endian = big_endian_host(); + ext = EXT(ctx); + ext->pid = pid; + ext->attach_callback = done; + ext->attach_data = data; + ext->attach_children = (mode & CONTEXT_ATTACH_CHILDREN) != 0; + list_add_first(&ctx->ctxl, &pending_list); + /* TODO: context_attach works only for main task in a process */ + return 0; +} + +int context_has_state(Context * ctx) { + return ctx != NULL && ctx->parent != NULL; +} + +int context_stop(Context * ctx) { + ContextExtensionLinux * ext = EXT(ctx); + trace(LOG_CONTEXT, "context:%s suspending ctx %#lx id %s", + ctx->pending_intercept ? "" : " temporary", ctx, ctx->id); + assert(is_dispatch_thread()); + assert(context_has_state(ctx)); + assert(!ctx->exited); + assert(!ctx->exiting); + assert(!ctx->stopped); + assert(!ext->regs_dirty); + if (ext->tkill_cnt > 4) { + /* Check for zombies */ + int ch = 0; + FILE * file = NULL; + char file_name[FILE_PATH_SIZE]; + snprintf(file_name, sizeof(file_name), "/proc/%d/stat", ext->pid); + if ((file = fopen(file_name, "r")) == NULL) return -1; + while (ch != EOF && ch != ')') ch = fgetc(file); + if (ch == EOF || fgetc(file) != ' ' || fgetc(file) == 'Z') { + /* Zombie found */ + fclose(file); + ctx->exiting = 1; + return 0; + } + fclose(file); + ext->tkill_cnt = 0; + } + if (tkill(ext->pid, SIGSTOP) < 0) { + int err = errno; + if (err == ESRCH) { + ctx->exiting = 1; + return 0; + } + trace(LOG_ALWAYS, "error: tkill(SIGSTOP) failed: ctx %#lx, id %s, error %d %s", + ctx, ctx->id, err, errno_to_str(err)); + errno = err; + return -1; + } + ext->tkill_cnt++; + return 0; +} + +static int syscall_never_returns(Context * ctx) { + if (EXT(ctx)->syscall_enter) { + switch (EXT(ctx)->syscall_id) { +#ifdef __NR_sigreturn + case __NR_sigreturn: + return 1; +#endif + } + } + return 0; +} + +int context_continue(Context * ctx) { + int signal = 0; + ContextExtensionLinux * ext = EXT(ctx); + + assert(is_dispatch_thread()); + assert(ctx->stopped); + assert(!ctx->pending_intercept); + assert(!ext->pending_step); + assert(!ctx->exited); + + if (skip_breakpoint(ctx, 0)) return 0; + + if (!ext->syscall_enter && !ext->ptrace_event) { + while (ctx->pending_signals != 0) { + while ((ctx->pending_signals & (1 << signal)) == 0) signal++; + if (ctx->sig_dont_pass & (1 << signal)) { + ctx->pending_signals &= ~(1 << signal); + signal = 0; + } + else { + break; + } + } + assert(signal != SIGSTOP); + assert(signal != SIGTRAP); + } + + trace(LOG_CONTEXT, "context: resuming ctx %#lx, id %s, with signal %d", ctx, ctx->id, signal); +#if defined(__i386__) || defined(__x86_64__) + if (ext->regs->eflags & 0x100) { + ext->regs->eflags &= ~0x100; + ext->regs_dirty = 1; + } +#endif + if (ext->regs_dirty) { + if (ptrace(PTRACE_SETREGS, ext->pid, 0, ext->regs) < 0) { + int err = errno; + if (err == ESRCH) { + ext->regs_dirty = 0; + ctx->exiting = 1; + send_context_started_event(ctx); + return 0; + } + trace(LOG_ALWAYS, "error: ptrace(PTRACE_SETREGS) failed: ctx %#lx, id %s, error %d %s", + ctx, ctx->id, err, errno_to_str(err)); + errno = err; + return -1; + } + ext->regs_dirty = 0; + } +#if USE_PTRACE_SYSCALL + if (ptrace(PTRACE_SYSCALL, ext->pid, 0, signal) < 0) { +#else + if (ptrace(PTRACE_CONT, ext->pid, 0, signal) < 0) { +#endif + int err = errno; + if (err == ESRCH) { + ctx->exiting = 1; + send_context_started_event(ctx); + return 0; + } + trace(LOG_ALWAYS, "error: ptrace(PTRACE_CONT, ...) failed: ctx %#lx, id %s, error %d %s", + ctx, ctx->id, err, errno_to_str(err)); + errno = err; + return -1; + } + ctx->pending_signals &= ~(1 << signal); + if (syscall_never_returns(ctx)) { + ext->syscall_enter = 0; + ext->syscall_exit = 0; + ext->syscall_id = 0; + } + send_context_started_event(ctx); + return 0; +} + +int context_single_step(Context * ctx) { + ContextExtensionLinux * ext = EXT(ctx); + + assert(is_dispatch_thread()); + assert(context_has_state(ctx)); + assert(ctx->stopped); + assert(!ctx->exited); + assert(!ext->pending_step); + + if (skip_breakpoint(ctx, 1)) return 0; + + if (syscall_never_returns(ctx)) return context_continue(ctx); + trace(LOG_CONTEXT, "context: single step ctx %#lx, id %s", ctx, ctx->id); + if (ext->regs_dirty) { + if (ptrace(PTRACE_SETREGS, ext->pid, 0, ext->regs) < 0) { + int err = errno; + if (err == ESRCH) { + ext->regs_dirty = 0; + ctx->exiting = 1; + send_context_started_event(ctx); + return 0; + } + trace(LOG_ALWAYS, "error: ptrace(PTRACE_SETREGS) failed: ctx %#lx, id %s, error %d %s", + ctx, ctx->id, err, errno_to_str(err)); + errno = err; + return -1; + } + ext->regs_dirty = 0; + } + if (ptrace(PTRACE_SINGLESTEP, ext->pid, 0, 0) < 0) { + int err = errno; + if (err == ESRCH) { + ctx->exiting = 1; + send_context_started_event(ctx); + return 0; + } + trace(LOG_ALWAYS, "error: ptrace(PTRACE_SINGLESTEP, ...) failed: ctx %#lx, id %s, error %d %s", + ctx, ctx->id, err, errno_to_str(err)); + errno = err; + return -1; + } + ext->pending_step = 1; + send_context_started_event(ctx); + return 0; +} + +int context_resume(Context * ctx, int mode, ContextAddress range_start, ContextAddress range_end) { + switch (mode) { + case RM_RESUME: + return context_continue(ctx); + case RM_STEP_INTO: + return context_single_step(ctx); + case RM_TERMINATE: + ctx->pending_signals |= 1 << SIGKILL; + return context_continue(ctx); + } + errno = ERR_UNSUPPORTED; + return -1; +} + +int context_can_resume(Context * ctx, int mode) { + switch (mode) { + case RM_RESUME: + return 1; + case RM_STEP_INTO: + case RM_TERMINATE: + return context_has_state(ctx); + } + return 0; +} + +int context_write_mem(Context * ctx, ContextAddress address, void * buf, size_t size) { + ContextAddress word_addr; + unsigned word_size = context_word_size(ctx); + ContextExtensionLinux * ext = EXT(ctx); + int error = 0; + + assert(word_size <= sizeof(unsigned long)); + assert(is_dispatch_thread()); + assert(!ctx->exited); + trace(LOG_CONTEXT, + "context: write memory ctx %#lx, id %s, address %#lx, size %zu", + ctx, ctx->id, address, size); + mem_err_info.error = 0; + if (size == 0) return 0; + if (check_breakpoints_on_memory_write(ctx, address, buf, size) < 0) return -1; + for (word_addr = address & ~((ContextAddress)word_size - 1); word_addr < address + size; word_addr += word_size) { + unsigned long word = 0; + if (word_addr < address || word_addr + word_size > address + size) { + unsigned i = 0; + errno = 0; + word = ptrace(PTRACE_PEEKDATA, ext->pid, (void *)word_addr, 0); + if (errno != 0) { + error = errno; + trace(LOG_CONTEXT, + "error: ptrace(PTRACE_PEEKDATA, ...) failed: ctx %#lx, id %s, addr %#lx, error %d %s", + ctx, ctx->id, word_addr, error, errno_to_str(error)); + break; + } + for (i = 0; i < word_size; i++) { + if (word_addr + i >= address && word_addr + i < address + size) { + ((char *)&word)[i] = ((char *)buf)[word_addr + i - address]; + } + } + } + else { + memcpy(&word, (char *)buf + (word_addr - address), word_size); + } + if (ptrace(PTRACE_POKEDATA, ext->pid, (void *)word_addr, word) < 0) { + error = errno; + trace(LOG_ALWAYS, + "error: ptrace(PTRACE_POKEDATA, ...) failed: ctx %#lx, id %s, addr %#lx, error %d %s", + ctx, ctx->id, word_addr, error, errno_to_str(error)); + break; + } + } + if (error) { +#if ENABLE_ExtendedMemoryErrorReports + size_t size_valid = 0; + size_t size_error = word_size; + if (word_addr > address) size_valid = (size_t)(word_addr - address); + /* Find number of invalid bytes */ + /* Note: cannot write memory here, read instead */ + while (size_error < 0x1000 && size_valid + size_error < size) { + errno = 0; + ptrace(PTRACE_PEEKDATA, ext->pid, (void *)(word_addr + size_error), 0); + if (errno != error) break; + size_error += word_size; + } + mem_err_info.error = error; + mem_err_info.size_valid = size_valid; + mem_err_info.size_error = size_error; +#endif + errno = error; + return -1; + } + return 0; +} + +int context_read_mem(Context * ctx, ContextAddress address, void * buf, size_t size) { + ContextAddress word_addr; + unsigned word_size = context_word_size(ctx); + ContextExtensionLinux * ext = EXT(ctx); + size_t size_valid = 0; + int error = 0; + + assert(word_size <= sizeof(unsigned long)); + assert(is_dispatch_thread()); + assert(!ctx->exited); + trace(LOG_CONTEXT, + "context: read memory ctx %#lx, id %s, address %#lx, size %zu", + ctx, ctx->id, address, size); + mem_err_info.error = 0; + if (size == 0) return 0; + for (word_addr = address & ~((ContextAddress)word_size - 1); word_addr < address + size; word_addr += word_size) { + unsigned long word = 0; + errno = 0; + word = ptrace(PTRACE_PEEKDATA, ext->pid, (void *)word_addr, 0); + if (errno != 0) { + error = errno; + trace(LOG_CONTEXT, + "error: ptrace(PTRACE_PEEKDATA, ...) failed: ctx %#lx, id %s, addr %#lx, error %d %s", + ctx, ctx->id, word_addr, error, errno_to_str(error)); + break; + } + if (word_addr < address || word_addr + word_size > address + size) { + unsigned i = 0; + for (i = 0; i < word_size; i++) { + if (word_addr + i >= address && word_addr + i < address + size) { + ((char *)buf)[word_addr + i - address] = ((char *)&word)[i]; + } + } + } + else { + memcpy((char *)buf + (word_addr - address), &word, word_size); + } + } + if (word_addr > address) size_valid = (size_t)(word_addr - address); + if (size_valid > size) size_valid = size; + if (check_breakpoints_on_memory_read(ctx, address, buf, size_valid) < 0) return -1; + if (error) { +#if ENABLE_ExtendedMemoryErrorReports + size_t size_error = word_size; + /* Find number of unreadable bytes */ + while (size_error < 0x1000 && size_valid + size_error < size) { + errno = 0; + ptrace(PTRACE_PEEKDATA, ext->pid, (void *)(word_addr + size_error), 0); + if (errno != error) break; + size_error += word_size; + } + mem_err_info.error = error; + mem_err_info.size_valid = size_valid; + mem_err_info.size_error = size_error; +#endif + errno = error; + return -1; + } + return 0; +} + +#if ENABLE_ExtendedMemoryErrorReports +int context_get_mem_error_info(MemoryErrorInfo * info) { + if (mem_err_info.error == 0) { + set_errno(ERR_OTHER, "Extended memory error info not available"); + return -1; + } + *info = mem_err_info; + return 0; +} +#endif + +int context_write_reg(Context * ctx, RegisterDefinition * def, unsigned offs, unsigned size, void * buf) { + ContextExtensionLinux * ext = EXT(ctx); + + assert(is_dispatch_thread()); + assert(context_has_state(ctx)); + assert(ctx->stopped); + assert(!ctx->exited); + assert(offs + size <= def->size); + + if (ext->regs_error) { + set_error_report_errno(ext->regs_error); + return -1; + } + memcpy((uint8_t *)ext->regs + def->offset + offs, buf, size); + ext->regs_dirty = 1; + return 0; +} + +int context_read_reg(Context * ctx, RegisterDefinition * def, unsigned offs, unsigned size, void * buf) { + ContextExtensionLinux * ext = EXT(ctx); + + assert(is_dispatch_thread()); + assert(context_has_state(ctx)); + assert(ctx->stopped); + assert(!ctx->exited); + assert(offs + size <= def->size); + + if (ext->regs_error) { + set_error_report_errno(ext->regs_error); + return -1; + } + memcpy(buf, (uint8_t *)ext->regs + def->offset + offs, size); + return 0; +} + +unsigned context_word_size(Context * ctx) { + return sizeof(void *); +} + +int context_get_canonical_addr(Context * ctx, ContextAddress addr, + Context ** canonical_ctx, ContextAddress * canonical_addr, + ContextAddress * block_addr, ContextAddress * block_size) { + /* Direct mapping, page size is irrelevant */ + ContextAddress page_size = 0x100000; + assert(is_dispatch_thread()); + *canonical_ctx = ctx->mem; + if (canonical_addr != NULL) *canonical_addr = addr; + if (block_addr != NULL) *block_addr = addr & ~(page_size - 1); + if (block_size != NULL) *block_size = page_size; + return 0; +} + +Context * context_get_group(Context * ctx, int group) { + static Context * cpu_group = NULL; + switch (group) { + case CONTEXT_GROUP_INTERCEPT: + return ctx; + case CONTEXT_GROUP_CPU: + if (cpu_group == NULL) cpu_group = create_context("CPU"); + return cpu_group; + } + return ctx->mem; +} + +int context_get_supported_bp_access_types(Context * ctx) { + return 0; +} + +int context_plant_breakpoint(ContextBreakpoint * bp) { + errno = ERR_UNSUPPORTED; + return -1; +} + +int context_unplant_breakpoint(ContextBreakpoint * bp) { + errno = ERR_UNSUPPORTED; + return -1; +} + +int context_get_memory_map(Context * ctx, MemoryMap * map) { + char maps_file_name[FILE_PATH_SIZE]; + FILE * file = NULL; + + ctx = ctx->mem; + assert(!ctx->exited); + assert(map->region_cnt == 0); + + snprintf(maps_file_name, sizeof(maps_file_name), "/proc/%d/maps", EXT(ctx)->pid); + if ((file = fopen(maps_file_name, "r")) == NULL) return -1; + for (;;) { + MemoryRegion * prev = NULL; + unsigned long addr0 = 0; + unsigned long addr1 = 0; + unsigned long offset = 0; + unsigned long dev_ma = 0; + unsigned long dev_mi = 0; + unsigned long inode = 0; + char permissions[16]; + char file_name[FILE_PATH_SIZE]; + unsigned i = 0; + int flags = 0; + + int cnt = fscanf(file, "%lx-%lx %s %lx %lx:%lx %ld", + &addr0, &addr1, permissions, &offset, &dev_ma, &dev_mi, &inode); + if (cnt == 0 || cnt == EOF) break; + + for (;;) { + int ch = fgetc(file); + if (ch == '\n' || ch == EOF) break; + if (i < FILE_PATH_SIZE - 1 && (ch != ' ' || i > 0)) { + file_name[i++] = ch; + } + } + file_name[i++] = 0; + + if (map->region_cnt >= map->region_max) { + map->region_max = map->region_max < 8 ? 8 : map->region_max * 2; + map->regions = (MemoryRegion *)loc_realloc(map->regions, sizeof(MemoryRegion) * map->region_max); + } + + for (i = 0; permissions[i]; i++) { + switch (permissions[i]) { + case 'r': flags |= MM_FLAG_R; break; + case 'w': flags |= MM_FLAG_W; break; + case 'x': flags |= MM_FLAG_X; break; + } + } + + if (map->region_cnt > 0) prev = map->regions + (map->region_cnt - 1); + + if (inode != 0 && file_name[0] && file_name[0] != '[') { + MemoryRegion * r = map->regions + map->region_cnt++; + memset(r, 0, sizeof(MemoryRegion)); + r->addr = addr0; + r->size = addr1 - addr0; + r->flags = flags; + r->file_offs = offset; + r->dev = MKDEV(dev_ma, dev_mi); + r->ino = (ino_t)inode; + r->file_name = loc_strdup(file_name); + } + else if (file_name[0] == 0 && prev != NULL && prev->addr + prev->size == addr0) { + MemoryRegion * r = map->regions + map->region_cnt++; + memset(r, 0, sizeof(MemoryRegion)); + r->bss = 1; + r->addr = addr0; + r->size = addr1 - addr0; + r->flags = flags; + r->file_offs = prev->file_offs + prev->size; + r->dev = prev->dev; + r->ino = prev->ino; + r->file_name = loc_strdup(prev->file_name); + } + } + fclose(file); + return 0; +} + +static Context * find_pending(pid_t pid) { + LINK * l = pending_list.next; + while (l != &pending_list) { + Context * c = ctxl2ctxp(l); + if (EXT(c)->pid == pid) { + list_remove(&c->ctxl); + return c; + } + l = l->next; + } + return NULL; +} + +static void event_pid_exited(pid_t pid, int status, int signal) { + Context * ctx; + + ctx = context_find_from_pid(pid, 1); + if (ctx == NULL) { + ctx = find_pending(pid); + if (ctx == NULL) { + trace(LOG_EVENTS, "event: ctx not found, pid %d, exit status %d, term signal %d", pid, status, signal); + } + else { + assert(ctx->ref_count == 0); + if (EXT(ctx)->attach_callback != NULL) { + if (status == 0) status = EINVAL; + EXT(ctx)->attach_callback(status, ctx, EXT(ctx)->attach_data); + } + assert(list_is_empty(&ctx->children)); + assert(ctx->parent == NULL); + ctx->exited = 1; + ctx->ref_count = 1; + context_unlock(ctx); + } + } + else { + /* Note: ctx->exiting should be 1 here. However, PTRACE_EVENT_EXIT can be lost by PTRACE because of racing + * between PTRACE_CONT (or PTRACE_SYSCALL) and SIGTRAP/PTRACE_EVENT_EXIT. So, ctx->exiting can be 0. + */ + if (EXT(ctx->parent)->pid == pid) ctx = ctx->parent; + trace(LOG_EVENTS, "event: ctx %#lx, pid %d, exit status %d, term signal %d", ctx, pid, status, signal); + assert(EXT(ctx)->attach_callback == NULL); + assert(!ctx->exited); + ctx->exiting = 1; + if (ctx->stopped) send_context_started_event(ctx); + if (!list_is_empty(&ctx->children)) { + LINK * l = ctx->children.next; + while (l != &ctx->children) { + Context * c = cldl2ctxp(l); + l = l->next; + assert(c->parent == ctx); + if (!c->exited) { + c->exiting = 1; + if (c->stopped) send_context_started_event(c); + release_error_report(EXT(c)->regs_error); + loc_free(EXT(c)->regs); + EXT(c)->regs_error = NULL; + EXT(c)->regs = NULL; + send_context_exited_event(c); + } + } + } + release_error_report(EXT(ctx)->regs_error); + loc_free(EXT(ctx)->regs); + EXT(ctx)->regs_error = NULL; + EXT(ctx)->regs = NULL; + send_context_exited_event(ctx); + } + assert(context_find_from_pid(pid, 1) == NULL); + assert(context_find_from_pid(pid, 0) == NULL); +} + +#if !USE_PTRACE_SYSCALL +# define get_syscall_id(ctx) 0 +#elif defined(__x86_64__) +# define get_syscall_id(ctx) (EXT(ctx)->regs->orig_rax) +#elif defined(__i386__) +# define get_syscall_id(ctx) (EXT(ctx)->regs->orig_eax) +#else +# error "get_syscall_id() is not implemented for CPU other then X86" +#endif + +static unsigned long get_child_pid(pid_t parent_pid) { + unsigned long child_pid = 0; + DIR * dir = NULL; + char task_file_name[FILE_PATH_SIZE]; + snprintf(task_file_name, sizeof(task_file_name), "/proc/%d/task", parent_pid); + dir = opendir(task_file_name); + if (dir == NULL) { + trace(LOG_ALWAYS, "error: opendir(%s) failed; error %d %s", + task_file_name, errno, errno_to_str(errno)); + } + else { + struct dirent * e; + for (;;) { + int n = 0; + e = readdir(dir); + if (e == NULL) break; + n = atoi(e->d_name); + if (n != 0 && context_find_from_pid(n, 1) == NULL) { + child_pid = n; + break; + } + } + closedir(dir); + } + return child_pid; +} + +static void event_pid_stopped(pid_t pid, int signal, int event, int syscall) { + int stopped_by_exception = 0; + unsigned long msg = 0; + Context * ctx = NULL; + ContextExtensionLinux * ext = NULL; + + trace(LOG_EVENTS, "event: pid %d stopped, signal %d, event %s", pid, signal, event_name(event)); + + ctx = context_find_from_pid(pid, 1); + + if (ctx == NULL) { + ctx = find_pending(pid); + if (ctx != NULL) { + Context * prs = ctx; + assert(prs->ref_count == 0); + ctx = create_context(pid2id(pid, pid)); + EXT(ctx)->pid = pid; + EXT(ctx)->regs = (REG_SET *)loc_alloc(sizeof(REG_SET)); + ctx->pending_intercept = 1; + ctx->mem = prs; + ctx->big_endian = prs->big_endian; + EXT(ctx)->attach_children = EXT(prs)->attach_children; + (ctx->parent = prs)->ref_count++; + list_add_last(&ctx->cldl, &prs->children); + link_context(prs); + link_context(ctx); + send_context_created_event(prs); + send_context_created_event(ctx); + if (EXT(prs)->attach_callback) { + EXT(prs)->attach_callback(0, prs, EXT(prs)->attach_data); + EXT(prs)->attach_callback = NULL; + EXT(prs)->attach_data = NULL; + } + } + } + + if (ctx == NULL) { + ctx = context_find_from_pid(pid, 0); + if (ctx != NULL) { + /* Fork child that we don't want to attach */ + unplant_breakpoints(ctx); + assert(ctx->ref_count == 1); + ctx->exited = 1; + if (ptrace((enum __ptrace_request)PTRACE_DETACH, pid, 0, 0) < 0) { + trace(LOG_ALWAYS, "error: ptrace(PTRACE_DETACH) failed: pid %d, error %d %s", + pid, errno, errno_to_str(errno)); + } + list_remove(ctx2pidlink(ctx)); + context_unlock(ctx); + } + detach_waitpid_process(); + return; + } + + ext = EXT(ctx); + assert(!ctx->exited); + assert(!ext->attach_callback); + ext->tkill_cnt = 0; + if (ext->ptrace_flags == 0) { + if (ptrace((enum __ptrace_request)PTRACE_SETOPTIONS, ext->pid, 0, PTRACE_FLAGS) < 0 && errno != ESRCH) { + int err = errno; + trace(LOG_ALWAYS, "error: ptrace(PTRACE_SETOPTIONS) failed: pid %d, error %d %s", + ext->pid, err, errno_to_str(err)); + } + else { + ext->ptrace_flags = PTRACE_FLAGS; + } + } + + switch (event) { + case PTRACE_EVENT_FORK: + case PTRACE_EVENT_VFORK: + case PTRACE_EVENT_CLONE: + if (ptrace((enum __ptrace_request)PTRACE_GETEVENTMSG, pid, 0, &msg) < 0) { + if (errno == ESRCH) { + msg = SIGKILL; + } + else { + trace(LOG_ALWAYS, "error: ptrace(PTRACE_GETEVENTMSG) failed; pid %d, error %d %s", + pid, errno, errno_to_str(errno)); + break; + } + } + { + Context * prs2 = NULL; + Context * ctx2 = NULL; + /* Check the thread is not killed already by SIGKILL */ + if (msg == SIGKILL) { + unsigned long child_pid = get_child_pid(EXT(ctx->parent)->pid); + if (child_pid) { + msg = child_pid; + } + else { + trace(LOG_ALWAYS, "cannot trace %s - aborted by SIGKILL", event_name(event)); + break; + } + } + assert(msg != 0); + add_waitpid_process(msg); + if (event == PTRACE_EVENT_CLONE) { + /* TODO: using the PTRACE_EVENT_CLONE to determine if the new context is a thread is not correct. + * The only way I know of is to look at the Tgid field of /proc/<pid>/status */ + prs2 = ctx->parent; + } + else { + prs2 = create_context(pid2id(msg, 0)); + EXT(prs2)->pid = msg; + EXT(prs2)->attach_children = ext->attach_children; + prs2->mem = prs2; + prs2->mem_access |= MEM_ACCESS_INSTRUCTION; + prs2->mem_access |= MEM_ACCESS_DATA; + prs2->mem_access |= MEM_ACCESS_USER; + prs2->big_endian = ctx->parent->big_endian; + (prs2->creator = ctx)->ref_count++; + prs2->sig_dont_stop = ctx->sig_dont_stop; + prs2->sig_dont_pass = ctx->sig_dont_pass; + link_context(prs2); + clone_breakpoints_on_process_fork(ctx, prs2); + if (!ext->attach_children) { + list_remove(&prs2->ctxl); + list_add_first(&prs2->ctxl, &detach_list); + break; + } + send_context_created_event(prs2); + } + + ctx2 = create_context(pid2id(msg, EXT(prs2)->pid)); + EXT(ctx2)->pid = msg; + EXT(ctx2)->attach_children = EXT(prs2)->attach_children; + EXT(ctx2)->regs = (REG_SET *)loc_alloc(sizeof(REG_SET)); + ctx2->mem = prs2; + ctx2->big_endian = prs2->big_endian; + ctx2->sig_dont_stop = ctx->sig_dont_stop; + ctx2->sig_dont_pass = ctx->sig_dont_pass; + (ctx2->creator = ctx)->ref_count++; + (ctx2->parent = prs2)->ref_count++; + list_add_last(&ctx2->cldl, &prs2->children); + link_context(ctx2); + trace(LOG_EVENTS, "event: new context 0x%x, id %s", ctx2, ctx2->id); + send_context_created_event(ctx2); + } + break; + case PTRACE_EVENT_EXEC: + send_context_changed_event(ctx); + memory_map_event_mapping_changed(ctx->mem); + break; + case PTRACE_EVENT_EXIT: + { + /* SIGKILL can override PTRACE_EVENT_CLONE event with PTRACE_EVENT_EXIT */ + unsigned long child_pid = get_child_pid(EXT(ctx->parent)->pid); + if (child_pid) { + Context * prs = ctx->parent; + Context * ctx2 = create_context(pid2id(child_pid, EXT(prs)->pid)); + EXT(ctx2)->pid = child_pid; + EXT(ctx2)->attach_children = EXT(prs)->attach_children; + EXT(ctx2)->regs = (REG_SET *)loc_alloc(sizeof(REG_SET)); + ctx2->mem = prs; + ctx2->big_endian = prs->big_endian; + ctx2->sig_dont_stop = ctx->sig_dont_stop; + ctx2->sig_dont_pass = ctx->sig_dont_pass; + ctx2->exiting = 1; + (ctx2->creator = ctx)->ref_count++; + (ctx2->parent = prs)->ref_count++; + list_add_last(&ctx2->cldl, &prs->children); + link_context(ctx2); + trace(LOG_EVENTS, "event: new context 0x%x, id %s", ctx2, ctx2->id); + send_context_created_event(ctx2); + event_pid_stopped(child_pid, SIGTRAP, 0, 0); + add_waitpid_process(child_pid); + } + } + ctx->exiting = 1; + ext->regs_dirty = 0; + break; + } + + if (signal != SIGSTOP && signal != SIGTRAP) { + assert(signal < 32); + ctx->pending_signals |= 1 << signal; + if ((ctx->sig_dont_stop & (1 << signal)) == 0) { + ctx->pending_intercept = 1; + stopped_by_exception = 1; + } + } + + if (ctx->stopped) { + if (event != PTRACE_EVENT_EXEC) send_context_changed_event(ctx); + } + else { + ContextAddress pc0 = 0; + ContextAddress pc1 = 0; + + assert(!ext->regs_dirty); + + ext->end_of_step = 0; + ext->ptrace_event = event; + ctx->signal = signal; + ctx->stopped_by_bp = 0; + ctx->stopped_by_exception = stopped_by_exception; + ctx->stopped = 1; + + if (ext->regs_error) { + release_error_report(ext->regs_error); + ext->regs_error = NULL; + } + else { + pc0 = get_regs_PC(ctx); + } + + if (ptrace(PTRACE_GETREGS, ext->pid, 0, ext->regs) < 0) { + assert(errno != 0); + if (errno == ESRCH) { + ctx->stopped = 0; + ctx->exiting = 1; + return; + } + ext->regs_error = get_error_report(errno); + trace(LOG_ALWAYS, "error: ptrace(PTRACE_GETREGS) failed; pid %d, error %d %s", + ext->pid, errno, errno_to_str(errno)); + } + else { + pc1 = get_regs_PC(ctx); + } + + if (syscall && !ext->regs_error) { + if (!ext->syscall_enter) { + ext->syscall_id = get_syscall_id(ctx); + ext->syscall_pc = pc1; + ext->syscall_enter = 1; + ext->syscall_exit = 0; + trace(LOG_EVENTS, "event: pid %d enter sys call %d, PC = %#lx", + pid, ext->syscall_id, ext->syscall_pc); + } + else { + if (ext->syscall_pc != pc1) { + trace(LOG_ALWAYS, "Invalid PC at sys call exit: pid %d, sys call %d, PC %#lx, expected PC %#lx", + ext->pid, ext->syscall_id, pc1, ext->syscall_pc); + } + trace(LOG_EVENTS, "event: pid %d exit sys call %d, PC = %#lx", + pid, ext->syscall_id, pc1); + switch (ext->syscall_id) { + case __NR_mmap: + case __NR_munmap: +#ifdef __NR_mmap2 + case __NR_mmap2: +#endif + case __NR_mremap: + case __NR_remap_file_pages: + memory_map_event_mapping_changed(ctx->mem); + break; + } + ext->syscall_enter = 0; + ext->syscall_exit = 1; + } + } + else { + if (!ext->syscall_enter || ext->regs_error || pc0 != pc1) { + ext->syscall_enter = 0; + ext->syscall_exit = 0; + ext->syscall_id = 0; + ext->syscall_pc = 0; + } + trace(LOG_EVENTS, "event: pid %d stopped at PC = %#lx", pid, pc1); + } + + if (signal == SIGTRAP && event == 0 && !syscall) { + size_t break_size = 0; + get_break_instruction(ctx, &break_size); + ctx->stopped_by_bp = !ext->regs_error && is_breakpoint_address(ctx, pc1 - break_size); + ext->end_of_step = !ctx->stopped_by_bp && ext->pending_step; + if (ctx->stopped_by_bp) set_regs_PC(ctx, pc1 - break_size); + } + ext->pending_step = 0; + send_context_stopped_event(ctx); + } +} + +static void waitpid_listener(int pid, int exited, int exit_code, int signal, int event_code, int syscall, void * args) { + if (exited) { + event_pid_exited(pid, exit_code, signal); + } + else { + event_pid_stopped(pid, signal, event_code, syscall); + } +} + +#if SERVICE_Expressions && ENABLE_ELF + +static int expression_identifier_callback(Context * ctx, int frame, char * name, Value * v) { + if (ctx == NULL) return 0; + if (strcmp(name, "$loader_brk") == 0) { + v->address = elf_get_debug_structure_address(ctx, NULL); + v->type_class = TYPE_CLASS_POINTER; + v->size = context_word_size(ctx); + if (v->address != 0) { + v->big_endian = ctx->big_endian; + switch (v->size) { + case 4: v->address += 8; break; + case 8: v->address += 16; break; + default: assert(0); + } + v->remote = 1; + } + else { + set_value(v, NULL, v->size, 0); + } + return 1; + } + if (strcmp(name, "$loader_state") == 0) { + v->address = elf_get_debug_structure_address(ctx, NULL); + v->type_class = TYPE_CLASS_CARDINAL; + v->size = context_word_size(ctx); + if (v->address != 0) { + switch (v->size) { + case 4: v->address += 12; break; + case 8: v->address += 24; break; + default: assert(0); + } + } + v->remote = 1; + return 1; + } + return 0; +} + +static void eventpoint_at_loader(Context * ctx, void * args) { + typedef enum { RT_CONSISTENT, RT_ADD, RT_DELETE } r_state; + ELF_File * file = NULL; + ContextAddress addr = elf_get_debug_structure_address(ctx, &file); + unsigned size = context_word_size(ctx); + ContextAddress state = 0; + ContextExtensionLinux * ext = NULL; + + + if (ctx->parent != NULL) ctx = ctx->parent; + ext = EXT(ctx); + + if (addr != 0) { + switch (size) { + case 4: addr += 12; break; + case 8: addr += 24; break; + default: assert(0); + } + if (elf_read_memory_word(ctx, file, addr, &state) < 0) { + int error = errno; + trace(LOG_ALWAYS, "Can't read loader state flag: %d %s", error, errno_to_str(error)); + ctx->pending_intercept = 1; + ext->loader_state = 0; + return; + } + } + + switch (state) { + case RT_CONSISTENT: + if (ext->loader_state == RT_ADD) { + memory_map_event_module_loaded(ctx); + } + else if (ext->loader_state == RT_DELETE) { + memory_map_event_module_unloaded(ctx); + } + break; + case RT_ADD: + break; + case RT_DELETE: + /* TODO: need to call memory_map_event_code_section_ummapped() */ + break; + } + ext->loader_state = state; +} + +#endif /* SERVICE_Expressions && ENABLE_ELF */ + +static void eventpoint_at_main(Context * ctx, void * args) { + send_context_changed_event(ctx->mem); + memory_map_event_mapping_changed(ctx->mem); + suspend_debug_context(ctx); +} + +void init_contexts_sys_dep(void) { + context_extension_offset = context_extension(sizeof(ContextExtensionLinux)); + add_waitpid_listener(waitpid_listener, NULL); + ini_context_pid_hash(); +#if SERVICE_Expressions && ENABLE_ELF + add_identifier_callback(expression_identifier_callback); + create_eventpoint("$loader_brk", NULL, eventpoint_at_loader, NULL); +#endif /* SERVICE_Expressions && ENABLE_ELF */ + create_eventpoint("main", NULL, eventpoint_at_main, NULL); +} + +#endif /* if ENABLE_DebugContext */ +#endif /* __linux__ */ |