fpsimd.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 <sys/proc.h>
#include <sys/sched.h>
#include <sys/signal.h>
 
MALLOC_DEFINE(M_FPSIMD, "fpsimd", "a thread's FP/SIMD registers");
 
/* CPACR_EL1.FPEN: user mode's use traps (0b01), or nothing does (0b11). */
#define CPACR_FPEN_EL0_TRAP     (1UL << 20)     /* 0b01 */
#define CPACR_FPEN_NONE         (3UL << 20)     /* 0b11 */
 
/* Saves the registers to `state`, or loads them from it (fpsimd_regs.S). */
 
void aarch64_fpsimd_save(void *state);
void aarch64_fpsimd_load(const void *state);
 
/* The thread whose values this CPU's registers hold. */
#define fp_thread (curcpu()->arch.fp_thread)

static void fpen(uint64_t v)
{
    write_sysreg(cpacr_el1, v);
    isb();
}

void aarch64_fpsimd_switch(struct thread *thread)
{
    fpen(thread && thread == fp_thread ? CPACR_FPEN_NONE : CPACR_FPEN_EL0_TRAP);
}

void *aarch64_fpsimd_current(struct thread *thread)
{
    struct aarch64_thread *arch = thread->arch;
 
    if (arch->fpsimd && fp_thread == thread)
        aarch64_fpsimd_save(arch->fpsimd);
 
    return arch->fpsimd;
}

int aarch64_fpsimd_trap(void)
{
    struct thread *thread = curthread;
    struct aarch64_thread *arch = thread->arch;
 
    if (!arch->fpsimd && !(arch->fpsimd = kmalloc(FPSIMD_STATE_SIZE, &M_FPSIMD, M_ZERO)))
        return -ENOMEM;
 
    if (fp_thread != thread) {
        if (fp_thread && fp_thread->arch)
            aarch64_fpsimd_save(((struct aarch64_thread *) fp_thread->arch)->fpsimd);
 
        aarch64_fpsimd_load(arch->fpsimd);
        fp_thread = thread;
    }
 
    fpen(CPACR_FPEN_NONE);
    return 0;
}

void aarch64_fpsimd_drop(struct thread *thread)
{
    struct aarch64_thread *arch = thread->arch;
 
    if (fp_thread == thread) {
        fp_thread = NULL;
        fpen(CPACR_FPEN_EL0_TRAP);
    }
 
    if (arch) {
        kfree(arch->fpsimd);
        arch->fpsimd = NULL;
    }
}

int aarch64_fpsimd_fork(struct thread *parent, struct aarch64_thread *child)
{
    void *state = aarch64_fpsimd_current(parent);
 
    if (!state)
        return 0;
 
    if (!(child->fpsimd = kmalloc(FPSIMD_STATE_SIZE, &M_FPSIMD, 0)))
        return -ENOMEM;
 
    memcpy(child->fpsimd, state, FPSIMD_STATE_SIZE);
    return 0;
}

void aarch64_fpsimd_restore(struct thread *thread, const void *state)
{
    struct aarch64_thread *arch = thread->arch;
 
    if (fp_thread == thread) {
        fp_thread = NULL;
        fpen(CPACR_FPEN_EL0_TRAP);
    }
 
    if (state && arch->fpsimd)
        memcpy(arch->fpsimd, state, FPSIMD_STATE_SIZE);
    else if (arch->fpsimd)
        memset(arch->fpsimd, 0, FPSIMD_STATE_SIZE);
}