signal.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <core/arch.h>
#include <core/string.h>
#include <cpu/cpu.h>
#include <ds/hashmap.h>
#include <mm/mm.h>
#include <mm/pmap.h>
#include <mm/vm.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/signal.h>
#include <sys/uaccess.h>
 
#include <aquila/syscall.h>
 
#if ARCH_BITS==32
#define REG_IP(r)   ((r)->eip)
#define REG_SP(r)   ((r)->esp)
#define REG_AX(r)   ((r)->eax)
#define REG_FLAGS(r) ((r)->eflags)
#else
#define REG_IP(r)   ((r)->rip)
#define REG_SP(r)   ((r)->rsp)
#define REG_AX(r)   ((r)->rax)
#define REG_FLAGS(r) ((r)->rflags)
#endif
 
/* the EFLAGS bits that user code may set: the arithmetic ones, TF, DF,
 * AC and ID (not IF, IOPL, NT, VM, ...) */
#define USER_FLAGS  0x00240DD5UL

struct sigframe {
    struct aquila_siginfo info;
    sigset_t mask;              /* the mask that sigreturn restores */
    uint32_t fpu;               /* fxsave below has the thread's FPU state */
    struct x86_regs regs;       /* the interrupted context */
    uint8_t fxsave[512] __aligned(16);
} __aligned(16);
 
/* On i386, below the frame: the return address and the handler's
 * arguments (signal, siginfo, ucontext), padded so that the handler is
 * entered as a call would enter it (the stack 16-byte aligned before the
 * call). */
#define I386_ARGS   20
 
/*
 * The sigcode page's code: mov $SYS_sigreturn, %eax; int $0x80; ud2
 */
static const uint8_t sigcode[] = {
    0xB8, SYS_sigreturn & 0xff, (SYS_sigreturn >> 8) & 0xff, 0, 0,
    0xCD, 0x80,
    0x0F, 0x0B,
};

static int vm_page_eq(void *a, void *b)
{
    return ((struct vm_page *) a)->off == *(size_t *) b;
}

static struct vm_page *sigcode_in(struct vm_object *vm_object, size_t off)
{
    char *buf = kmalloc(PAGE_SIZE, &M_BUFFER, M_ZERO);
    struct vm_page *vm_page = buf ? mm_page_alloc() : NULL;
 
    if (!vm_page) {
        kfree(buf);
        return NULL;
    }
 
    memcpy(buf, sigcode, sizeof(sigcode));
    pmap_page_write(vm_page->paddr, 0, PAGE_SIZE, buf);
    kfree(buf);
 
    vm_page->vm_object = vm_object;
    vm_page->off = 0;
    vm_page->ref = 1;
 
    if (vm_object_page_insert(vm_object, vm_page)) {
        mm_page_dealloc(vm_page->paddr);
        return NULL;
    }
 
    return vm_page;
}
 
static struct vm_pager sigcode_pager = {
    .in = sigcode_in,
};
 
static struct vm_object sigcode_object = {
    .pager = &sigcode_pager,
    .ref   = 1,
};
 
/*
 * Maps the sigcode page in a process's new address space.
 */
int arch_sigcode_map(struct proc *proc)
{
    if (!sigcode_object.pages && !(sigcode_object.pages = hashmap_new(0, vm_page_eq)))
        return -ENOMEM;
 
    struct vm_entry *vm_entry = kmalloc(sizeof(struct vm_entry), &M_VM_ENTRY, M_ZERO);
 
    if (!vm_entry)
        return -ENOMEM;
 
    vm_entry->base  = SIGCODE_ADDR;
    vm_entry->size  = PAGE_SIZE;
    vm_entry->flags = VM_URX;
    vm_entry->vm_object = &sigcode_object;
 
    int err = vm_space_insert(&proc->vm_space, vm_entry);
 
    if (err) {
        kfree(vm_entry);
        return err;
    }
 
    vm_object_incref(&sigcode_object);
    return 0;
}

static void deliver(struct x86_regs *r, int sig)
{
    struct thread *thread = curthread;
    struct proc *proc = curproc;
    struct aquila_sigaction *sa = &proc->sigaction[sig];
    uintptr_t handler = sa->sa_handler;
 
    /* the mask to restore afterwards; for sigsuspend() and pselect(),
     * it is the one they replaced */
    sigset_t mask = thread->sig_oldmask_set ? thread->sig_oldmask : proc->sigmask;
    thread->sig_oldmask_set = 0;
 
#if ARCH_BITS==32
    uintptr_t sp = REG_SP(r);
#else
    /* below the red zone, the 128 bytes the code may use below its stack
     * pointer */
    uintptr_t sp = REG_SP(r) - 128;
#endif
 
    uintptr_t f = (sp - sizeof(struct sigframe)) & ~(uintptr_t) 15;
 
#if ARCH_BITS==32
    uintptr_t new_sp = f - I386_ARGS;
#else
    uintptr_t new_sp = f - sizeof(uintptr_t);
#endif
 
    /* make the frame here, zeroed, so that nothing of the kernel's goes
     * out */
    struct sigframe frame;
    struct sigframe *uframe = (struct sigframe *) f;
    int fault = sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || sig == SIGFPE;
 
    memset(&frame, 0, sizeof(frame));
    frame.info = (struct aquila_siginfo) {
        .si_signo = sig,
        .si_addr  = fault ? thread->fault_addr : 0,
    };
    frame.mask = mask;
    frame.regs = *r;
    frame.fpu  = x86_fpu_save_to(frame.fxsave);
 
    /* below it, what the handler returns to (and its arguments) */
#if ARCH_BITS==32
    uintptr_t args[I386_ARGS / sizeof(uintptr_t)] = {
        SIGCODE_ADDR, sig, (uintptr_t) &uframe->info, 0, 0,
    };
#else
    uintptr_t args[1] = {SIGCODE_ADDR};
#endif
 
    /* if there's nowhere to put it, the process can't go on, as after a
     * fault */
    if (sp < 4096 || copyout(uframe, &frame, sizeof(frame)) ||
        copyout((void *) new_sp, args, sizeof(args)))
        signal_exit(SIGSEGV);
 
    /* the handler starts with a clean FPU state */
    x86_fpu_reset();
 
#if ARCH_BITS==64
    r->rdi = sig;
    r->rsi = (uintptr_t) &uframe->info;
    r->rdx = 0;
#endif
 
    REG_IP(r) = handler;
    REG_SP(r) = new_sp;
    REG_FLAGS(r) = (REG_FLAGS(r) & USER_FLAGS & ~0x400UL) | X86_EFLAGS;  /* DF clear */
 
    /* while it runs, its mask is blocked, and the signal itself (unless
     * SA_NODEFER) */
    sigset_t block = sa->sa_mask | (sa->sa_flags & SA_NODEFER ? 0 : 1UL << sig);
    proc->sigmask = (mask | block) & ~SIG_UNMASKABLE;
 
    if (sa->sa_flags & SA_RESETHAND)
        sa->sa_handler = SIG_DFL;
}

void x86_return_to_user(struct x86_regs *r, int syscall)
{
    struct thread *thread = curthread;
 
    if (!thread || !thread->arch || (r->cs & 3) != 3)
        return;
 
    struct proc *proc = thread->owner;
    int sig = signal_take();
 
    /* a system call that a signal interrupted is made again (if no
     * handler runs, or the handler says SA_RESTART), or fails with EINTR */
    if (syscall) {
        intptr_t ret = (intptr_t) REG_AX(r);
 
        if (ret == -ERESTARTSYS || ret == -ERESTARTNOHAND) {
            int restart = !sig || (ret == -ERESTARTSYS && (proc->sigaction[sig].sa_flags & SA_RESTART));
 
            if (restart) {
                /* back to the int $0x80, with the number in eax again */
                REG_IP(r) -= 2;
                REG_AX(r) = thread->syscall_nr;
 
                /* straight back into the same call, with the same
                 * arguments: it may go on where it was (if a handler runs
                 * first, its calls aren't the restart) */
                thread->restarting = !sig;
            } else {
                REG_AX(r) = -EINTR;
            }
        }
    }
 
    if (sig) {
        deliver(r, sig);
    } else if (thread->sig_oldmask_set) {
        /* sigsuspend() restarted: restore the mask it replaced */
        proc->sigmask = thread->sig_oldmask;
        thread->sig_oldmask_set = 0;
    }
}
 
/* Returns from a signal handler (`sigreturn`): restores the interrupted
 * context, the mask and the FPU state from the handler's frame. A bad
 * frame raises `SIGSEGV`. */
void arch_sigreturn(void)
{
    struct x86_thread *arch = curthread->arch;
    struct x86_regs *r = arch->regs;
 
#if ARCH_BITS==32
    uintptr_t f = REG_SP(r) + I386_ARGS - sizeof(uintptr_t);
#else
    uintptr_t f = REG_SP(r);
#endif
 
    struct sigframe frame;
 
    if ((f & 15) || copyin(&frame, (void *) f, sizeof(frame))) {
        signal_force(curproc, SIGSEGV);
        return;
    }
 
    /* the frame's registers, but with user mode's segments, and no flags
     * that user mode couldn't set itself */
    uintptr_t flags = (REG_FLAGS(&frame.regs) & USER_FLAGS) | X86_EFLAGS;
 
    *r = frame.regs;
    REG_FLAGS(r) = flags;
    r->cs = X86_CS;
    r->ss = X86_SS;
 
#if ARCH_BITS==32
    r->ds = r->es = r->fs = r->gs = X86_SS;
#endif
 
    curproc->sigmask = frame.mask & ~SIG_UNMASKABLE;
    x86_fpu_load_from(frame.fxsave, frame.fpu);
}