void
trap(unsigned status, unsigned cause, unsigned epc,
md_thread_t *frame)
{
const int exc = cause & CAUSE_EXC_MASK;
DPRINTF("status:%x cause:%x epc:%x exc:%x\n",
status, cause, epc, exc);
switch(exc) {
case EXC_INT:
interrupt_handle(cause & CAUSE_IP_MASK);
break;
case EXC_SYS:
syscall_handle(status, cause, epc, frame);
break;
default:
printf("[general exception]\n");
dump_frame(frame);
while(1)
;
}
}
/** Handles an exception (code != 0) that occured in user mode. Will
* call appropiate handlers for the exception or panic if the
* exception should not have occured or does not (yet) have a handler.
* Interrupts are disabled by EXL when this function is called, and
* must be so when this fucntion returns. Interrupts may be enabled
* during execution of this function if needed.
*
* @param exception The exception code field from the CP0 Cause register
*/
void user_exception_handle(int exception)
{
thread_table_t *my_entry;
/* While interrupts are disabled here, they can be enabled when
handling system calls and certain other exceptions if needed.
For normal TLB exceptions it is not desirable that context is
switched before TLB is filled. */
_interrupt_disable();
/* Clear EXL to make normal interrupt disable/enable work. */
_interrupt_clear_EXL();
/* Save usermode context to user_context for later reference in syscalls */
my_entry= thread_get_current_thread_entry();
my_entry->user_context = my_entry->context;
switch(exception) {
case EXCEPTION_TLBM:
tlb_modified_exception();
break;
case EXCEPTION_TLBL:
tlb_load_exception();
break;
case EXCEPTION_TLBS:
tlb_store_exception();
break;
case EXCEPTION_ADDRL:
KERNEL_PANIC("Address Error Load: not handled yet");
break;
case EXCEPTION_ADDRS:
KERNEL_PANIC("Address Error Store: not handled yet");
break;
case EXCEPTION_BUSI:
KERNEL_PANIC("Bus Error Instruction: not handled yet");
break;
case EXCEPTION_BUSD:
KERNEL_PANIC("Bus Error Data: not handled yet");
break;
case EXCEPTION_SYSCALL:
_interrupt_enable();
syscall_handle(my_entry->user_context);
_interrupt_disable();
break;
case EXCEPTION_BREAK:
KERNEL_PANIC("Breakpoint: not handled yet");
break;
case EXCEPTION_RESVI:
kprintf("Thread ID: %d\n", thread_get_current_thread());
KERNEL_PANIC("Reserved instruction: not handled yet");
break;
case EXCEPTION_COPROC:
KERNEL_PANIC("Coprocessor unusable: buggy assembler code?");
break;
case EXCEPTION_AOFLOW:
KERNEL_PANIC("Arithmetic overflow: buggy assembler code?");
break;
case EXCEPTION_TRAP:
KERNEL_PANIC("Trap: this just should not happen");
break;
default:
KERNEL_PANIC("Unknown exception");
}
/* Interrupts are disabled by setting EXL after this point. */
_interrupt_set_EXL();
_interrupt_enable();
}
static int trace(pid_t first_proc, int *first_exit_code)
{
for(;;)
{
int status;
pid_t tid;
int cpu_time;
struct Process *process;
/* Wait for a process */
#if NO_WAIT3
tid = waitpid(-1, &status, __WALL);
cpu_time = -1;
#else
{
struct rusage res;
tid = wait3(&status, __WALL, &res);
cpu_time = (res.ru_utime.tv_sec * 1000 +
res.ru_utime.tv_usec / 1000);
}
#endif
if(tid == -1)
{
/* LCOV_EXCL_START : internal error: waitpid() won't fail unless we
* mistakingly call it while there is no child to wait for */
log_critical(0, "waitpid failed: %s", strerror(errno));
return -1;
/* LCOV_EXCL_END */
}
if(WIFEXITED(status) || WIFSIGNALED(status))
{
unsigned int nprocs, unknown;
int exitcode;
if(WIFSIGNALED(status))
/* exit codes are 8 bits */
exitcode = 0x0100 | WTERMSIG(status);
else
exitcode = WEXITSTATUS(status);
if(tid == first_proc && first_exit_code != NULL)
*first_exit_code = exitcode;
process = trace_find_process(tid);
if(process != NULL)
{
int cpu_time_val = -1;
if(process->tid == process->threadgroup->tgid)
cpu_time_val = cpu_time;
if(db_add_exit(process->identifier, exitcode,
cpu_time_val) != 0)
return -1;
trace_free_process(process);
}
trace_count_processes(&nprocs, &unknown);
if(verbosity >= 2)
log_info(tid, "process exited (%s %d), CPU time %.2f, "
"%d processes remain",
(exitcode & 0x0100)?"signal":"code", exitcode & 0xFF,
cpu_time * 0.001f, (unsigned int)nprocs);
if(nprocs <= 0)
break;
if(unknown >= nprocs)
{
/* LCOV_EXCL_START : This can't happen because UNKNOWN
* processes are the forked processes whose creator has not
* returned yet. Therefore, if there is an UNKNOWN process, its
* creator has to exist as well (and it is not UNKNOWN). */
log_critical(0, "only UNKNOWN processes remaining (%d)",
(unsigned int)nprocs);
return -1;
/* LCOV_EXCL_END */
}
continue;
}
process = trace_find_process(tid);
if(process == NULL)
{
if(verbosity >= 3)
log_debug(tid, "process appeared");
process = trace_get_empty_process();
process->status = PROCSTAT_UNKNOWN;
process->flags = 0;
process->tid = tid;
process->threadgroup = NULL;
process->in_syscall = 0;
trace_set_options(tid);
/* Don't resume, it will be set to ATTACHED and resumed when fork()
* returns */
continue;
}
else if(process->status == PROCSTAT_ALLOCATED)
{
process->status = PROCSTAT_ATTACHED;
if(verbosity >= 3)
log_debug(tid, "process attached");
trace_set_options(tid);
ptrace(PTRACE_SYSCALL, tid, NULL, NULL);
if(verbosity >= 2)
{
unsigned int nproc, unknown;
trace_count_processes(&nproc, &unknown);
log_info(0, "%d processes (inc. %d unattached)",
nproc, unknown);
}
continue;
}
if(WIFSTOPPED(status) && WSTOPSIG(status) & 0x80)
{
size_t len = 0;
#ifdef I386
struct i386_regs regs;
#else /* def X86_64 */
struct x86_64_regs regs;
#endif
/* Try to use GETREGSET first, since iov_len allows us to know if
* 32bit or 64bit mode was used */
#ifdef PTRACE_GETREGSET
#ifndef NT_PRSTATUS
#define NT_PRSTATUS 1
#endif
{
struct iovec iov;
iov.iov_base = ®s;
iov.iov_len = sizeof(regs);
if(ptrace(PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov) == 0)
len = iov.iov_len;
}
if(len == 0)
#endif
/* GETREGSET undefined or call failed, fallback on GETREGS */
{
/* LCOV_EXCL_START : GETREGSET was added by Linux 2.6.34 in
* May 2010 (2225a122) */
ptrace(PTRACE_GETREGS, tid, NULL, ®s);
/* LCOV_EXCL_END */
}
#if defined(I386)
if(!process->in_syscall)
process->current_syscall = regs.orig_eax;
if(process->in_syscall)
get_i386_reg(&process->retvalue, regs.eax);
else
{
get_i386_reg(&process->params[0], regs.ebx);
get_i386_reg(&process->params[1], regs.ecx);
get_i386_reg(&process->params[2], regs.edx);
get_i386_reg(&process->params[3], regs.esi);
get_i386_reg(&process->params[4], regs.edi);
get_i386_reg(&process->params[5], regs.ebp);
}
process->mode = MODE_I386;
#elif defined(X86_64)
/* On x86_64, process might be 32 or 64 bits */
/* If len is known (not 0) and not that of x86_64 registers,
* or if len is not known (0) and CS is 0x23 (not as reliable) */
if( (len != 0 && len != sizeof(regs))
|| (len == 0 && regs.cs == 0x23) )
{
/* 32 bit mode */
struct i386_regs *x86regs = (struct i386_regs*)®s;
if(!process->in_syscall)
process->current_syscall = x86regs->orig_eax;
if(process->in_syscall)
get_i386_reg(&process->retvalue, x86regs->eax);
else
{
get_i386_reg(&process->params[0], x86regs->ebx);
get_i386_reg(&process->params[1], x86regs->ecx);
get_i386_reg(&process->params[2], x86regs->edx);
get_i386_reg(&process->params[3], x86regs->esi);
get_i386_reg(&process->params[4], x86regs->edi);
get_i386_reg(&process->params[5], x86regs->ebp);
}
process->mode = MODE_I386;
}
else
{
/* 64 bit mode */
if(!process->in_syscall)
process->current_syscall = regs.orig_rax;
if(process->in_syscall)
get_x86_64_reg(&process->retvalue, regs.rax);
else
{
get_x86_64_reg(&process->params[0], regs.rdi);
get_x86_64_reg(&process->params[1], regs.rsi);
get_x86_64_reg(&process->params[2], regs.rdx);
get_x86_64_reg(&process->params[3], regs.r10);
get_x86_64_reg(&process->params[4], regs.r8);
get_x86_64_reg(&process->params[5], regs.r9);
}
/* Might still be either native x64 or Linux's x32 layer */
process->mode = MODE_X86_64;
}
#endif
if(syscall_handle(process) != 0)
return -1;
}
/* Handle signals */
else if(WIFSTOPPED(status))
{
int signum = WSTOPSIG(status) & 0x7F;
/* Synthetic signal for ptrace event: resume */
if(signum == SIGTRAP && status & 0xFF0000)
{
int event = status >> 16;
if(event == PTRACE_EVENT_EXEC)
{
log_debug(tid,
"got EVENT_EXEC, an execve() was successful and "
"will return soon");
if(syscall_execve_event(process) != 0)
return -1;
}
else if( (event == PTRACE_EVENT_FORK)
|| (event == PTRACE_EVENT_VFORK)
|| (event == PTRACE_EVENT_CLONE))
{
if(syscall_fork_event(process, event) != 0)
return -1;
}
ptrace(PTRACE_SYSCALL, tid, NULL, NULL);
}
else if(signum == SIGTRAP)
{
/* LCOV_EXCL_START : Processes shouldn't be getting SIGTRAPs */
log_error(0,
"NOT delivering SIGTRAP to %d\n"
" waitstatus=0x%X", tid, status);
ptrace(PTRACE_SYSCALL, tid, NULL, NULL);
/* LCOV_EXCL_END */
}
/* Other signal, let the process handle it */
else
{
siginfo_t si;
if(verbosity >= 2)
log_info(tid, "caught signal %d", signum);
if(ptrace(PTRACE_GETSIGINFO, tid, 0, (long)&si) >= 0)
ptrace(PTRACE_SYSCALL, tid, NULL, signum);
else
{
/* LCOV_EXCL_START : Not sure what this is for... doesn't
* seem to happen in practice */
log_error(tid, " NOT delivering: %s", strerror(errno));
if(signum != SIGSTOP)
ptrace(PTRACE_SYSCALL, tid, NULL, NULL);
/* LCOV_EXCL_END */
}
}
}
