main.c

Go to the documentation of this file.

 
#include <xtf.h>
 
const char test_title[] = "FPU Exception Emulation";
 
#define CR0_SYM(...) TOK_OR(X86_CR0_, ##__VA_ARGS__)
#define CR0_MASK CR0_SYM(EM, MP, TS)
 
struct test_cfg
{
    unsigned long cr0;
    exinfo_t fault;
};
 
static unsigned long default_cr0;
 
static const struct test_cfg x87[] =
{
    { CR0_SYM(          ), 0 },
    { CR0_SYM(        TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(    MP    ), 0 },
    { CR0_SYM(    MP, TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM        ), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM,     TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM, MP    ), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM, MP, TS), EXINFO_SYM(NM, 0) },
};
 
exinfo_t probe_x87(bool force)
{
    exinfo_t fault = 0;
 
    asm volatile ("test %[fep], %[fep];"
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: fnop; 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+a" (fault)
                  : [fep] "q" (force),
                    [rec] "p" (ex_record_fault_eax));
 
    return fault;
}
 
static const struct test_cfg x87_wait[] =
{
    { CR0_SYM(          ), 0 },
    { CR0_SYM(        TS), 0 },
    { CR0_SYM(    MP    ), 0 },
    { CR0_SYM(    MP, TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM        ), 0 },
    { CR0_SYM(EM,     TS), 0 },
    { CR0_SYM(EM, MP    ), 0 },
    { CR0_SYM(EM, MP, TS), EXINFO_SYM(NM, 0) },
};
 
exinfo_t probe_x87_wait(bool force)
{
    exinfo_t fault = 0;
 
    asm volatile ("test %[fep], %[fep];"
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: wait; 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+a" (fault)
                  : [fep] "q" (force),
                    [rec] "p" (ex_record_fault_eax));
 
    return fault;
}
 
static const struct test_cfg mmx_sse[] =
{
    { CR0_SYM(          ), 0 },
    { CR0_SYM(        TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(    MP    ), 0 },
    { CR0_SYM(    MP, TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM        ), EXINFO_SYM(UD, 0) },
    { CR0_SYM(EM,     TS), EXINFO_SYM(UD, 0) },
    { CR0_SYM(EM, MP    ), EXINFO_SYM(UD, 0) },
    { CR0_SYM(EM, MP, TS), EXINFO_SYM(UD, 0) },
};
 
exinfo_t probe_mmx(bool force)
{
    exinfo_t fault = 0;
 
    asm volatile ("test %[fep], %[fep];"
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: movq %%mm0, %%mm0; 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+a" (fault)
                  : [fep] "q" (force),
                    [rec] "p" (ex_record_fault_eax));
 
    return fault;
}
 
exinfo_t probe_sse(bool force)
{
    exinfo_t fault = 0;
 
    asm volatile ("test %[fep], %[fep];"
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: movups %%xmm0, %%xmm0; 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+a" (fault)
                  : [fep] "q" (force),
                    [rec] "p" (ex_record_fault_eax));
 
    return fault;
}
 
static const struct test_cfg avx[] =
{
    { CR0_SYM(          ), 0 },
    { CR0_SYM(        TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(    MP    ), 0 },
    { CR0_SYM(    MP, TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM        ), 0 },
    { CR0_SYM(EM,     TS), EXINFO_SYM(NM, 0) },
    { CR0_SYM(EM, MP    ), 0 },
    { CR0_SYM(EM, MP, TS), EXINFO_SYM(NM, 0) },
};
 
static exinfo_t probe_avx(bool force)
{
    exinfo_t fault = 0;
 
    asm volatile ("test %[fep], %[fep];"
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: vmovups %%xmm0, %%xmm0; 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+a" (fault)
                  : [fep] "q" (force),
                    [rec] "p" (ex_record_fault_eax));
 
    return fault;
}
 
void run_sequence(const struct test_cfg *seq, unsigned int nr,
                  unsigned int (*fn)(bool), bool force, exinfo_t override)
{
    unsigned int i;
 
    for ( i = 0; i < nr; ++i )
    {
        const struct test_cfg *t = &seq[i];
        exinfo_t res, exp = override ?: t->fault;
 
        write_cr0((default_cr0 & ~CR0_MASK) | t->cr0);
        res = fn(force);
 
        if ( res != exp )
        {
            char cr0str[12];
 
            snprintf(cr0str, sizeof(cr0str), "%s%s%s",
                     t->cr0 & X86_CR0_EM ? " EM" : "",
                     t->cr0 & X86_CR0_MP ? " MP" : "",
                     t->cr0 & X86_CR0_TS ? " TS" : "");
 
            xtf_failure("  Expected %pe, got %pe (cr0:%s)\n",
                        _p(exp), _p(res), cr0str[0] ? cr0str : " - ");
        }
    }
}
 
void run_tests(bool force)
{
    if ( cpu_has_fpu )
    {
        printk("Testing%s x87\n", force ? " emulated" : "");
        run_sequence(x87, ARRAY_SIZE(x87), probe_x87, force, 0);
 
        printk("Testing%s x87 wait\n", force ? " emulated" : "");
        run_sequence(x87_wait, ARRAY_SIZE(x87_wait), probe_x87_wait, force, 0);
    }
 
    if ( cpu_has_mmx )
    {
        printk("Testing%s MMX\n", force ? " emulated" : "");
        run_sequence(mmx_sse, ARRAY_SIZE(mmx_sse), probe_mmx, force, 0);
    }
 
    if ( cpu_has_sse )
    {
        unsigned long cr4 = read_cr4();
 
        printk("Testing%s SSE\n", force ? " emulated" : "");
        write_cr4(cr4 & ~X86_CR4_OSFXSR);
        run_sequence(mmx_sse, ARRAY_SIZE(mmx_sse), probe_sse, force,
                     EXINFO_SYM(UD, 0));
 
        printk("Testing%s SSE (CR4.OSFXSR)\n", force ? " emulated" : "");
        write_cr4(cr4 | X86_CR4_OSFXSR);
        run_sequence(mmx_sse, ARRAY_SIZE(mmx_sse), probe_sse, force, 0);
 
        write_cr4(cr4);
    }
 
    if ( cpu_has_avx )
    {
        unsigned long cr4 = read_cr4();
        unsigned long xcr0;
 
        printk("Testing%s AVX\n", force ? " emulated" : "");
        write_cr4(cr4 & ~X86_CR4_OSXSAVE);
        run_sequence(avx, ARRAY_SIZE(avx), probe_avx, force,
                     EXINFO_SYM(UD, 0));
 
        printk("Testing%s AVX (CR4.OSXSAVE)\n", force ? " emulated" : "");
        write_cr4(cr4 | X86_CR4_OSXSAVE);
        xcr0 = read_xcr0();
        write_xcr0(xcr0 & ~XSTATE_YMM);
        run_sequence(avx, ARRAY_SIZE(avx), probe_avx, force,
                     EXINFO_SYM(UD, 0));
 
        printk("Testing%s AVX (CR4.OSXSAVE+XCR0.YMM)\n", force ? " emulated" : "");
        write_xcr0(xcr0 | XSTATE_SSE | XSTATE_YMM);
        run_sequence(avx, ARRAY_SIZE(avx), probe_avx, force, 0);
 
        write_xcr0(xcr0);
        write_cr4(cr4);
    }
}
 
void test_main(void)
{
    default_cr0 = read_cr0();
 
    run_tests(false);
 
    if ( !xtf_has_fep )
        xtf_skip("FEP support not detected - some tests will be skipped\n");
    else
        run_tests(true);
 
    xtf_success(NULL);
}
 
/*
 * Local variables:
 * mode: C
 * c-file-style: "BSD"
 * c-basic-offset: 4
 * tab-width: 4
 * indent-tabs-mode: nil
 * End:
 */