main.c

Go to the documentation of this file.

 
#include <xtf.h>
 
const char test_title[] = "Invlpg tests";
 
/* Swizzle to easily change all invlpg instructions to being emulated. */
#if 0
#define _ASM_MAYBE_XEN_FEP _ASM_XEN_FEP
#else
#define _ASM_MAYBE_XEN_FEP
#endif
 
static bool ex_fail(struct cpu_regs *regs, const struct extable_entry *ex)
{
    exinfo_t info = EXINFO(regs->entry_vector, regs->error_code);
 
    xtf_failure("    Fail: Unexpected fault %#x, %pe\n", info, _p(info));
 
    regs->ip = ex->fixup;
    return true;
}
 
static bool test_ad(uint64_t pte)
{
    return (pte & _PAGE_AD) == _PAGE_AD;
}
 
static unsigned int invlpg_refill(void)
{
    asm volatile ("mov %[zero], 0x1000;\n\t"   /* Force TLB fill. */
                  "mov %[zero], 0x2000;\n\t"
                  "andb $~%c[ad], %[pte1];\n\t" /* Clear A/D bits. */
                  "andb $~%c[ad], %[pte2];\n\t"
                  _ASM_MAYBE_XEN_FEP
                  "1: invlpg 0x1000; 2:\n\t"   /* Invalidate one page only. */
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                  "mov %[zero], 0x1000;\n\t"   /* Expect refill. */
                  "mov %[zero], 0x2000;\n\t"   /* Expect no refill. */
                  :
                  : [zero] "r" (0),
                    [ad]   "i" (_PAGE_AD),
                    [pte1] "m" (pae_l1_identmap[1]),
                    [pte2] "m" (pae_l1_identmap[2]),
                    [hnd] "p" (ex_fail)
                  : "memory");
 
    return ((test_ad(pae_l1_identmap[1]) << 0) |
            (test_ad(pae_l1_identmap[2]) << 1));
}
 
static unsigned int invlpg_fs_refill(void)
{
    asm volatile ("mov %[zero], 0x1000;\n\t"  /* Force TLB fill. */
                  "mov %[zero], 0x2000;\n\t"
                  "andb $~%c[ad], %[pte1];\n\t" /* Clear A/D bits. */
                  "andb $~%c[ad], %[pte2];\n\t"
                  _ASM_MAYBE_XEN_FEP
                  "1: invlpg %%fs:0x1000; 2:\n\t" /* Invalidate one page only. */
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                  "mov %[zero], 0x1000;\n\t"  /* Expect one TLB entry to refil, */
                  "mov %[zero], 0x2000;\n\t"  /* depending on %fs base.*/
                  :
                  : [zero] "r" (0),
                    [ad]   "i" (_PAGE_AD),
                    [pte1] "m" (pae_l1_identmap[1]),
                    [pte2] "m" (pae_l1_identmap[2]),
                    [hnd] "p" (ex_fail)
                  : "memory");
 
    return ((test_ad(pae_l1_identmap[1]) << 0) |
            (test_ad(pae_l1_identmap[2]) << 1));
}
 
static void run_tlb_refill_test(unsigned int (*fn)(void), unsigned int expect)
{
    unsigned int ret, tries = 20;
 
    do
    {
        ret = fn();
        /*
         * Tests are racy if a vcpu reschedule happens in the asm blocks, as
         * the TLB on the new vcpu will be empty and extra refills will occur.
         * If a refil of both entries occurs, repeat the test quickly several
         * times in the hope that one doesn't hit a reschedule point.
         */
    } while ( ret == 3 && --tries );
 
    switch ( ret )
    {
    case 0:
        return xtf_failure("    Fail: No TLB refill at all\n");
        break;
 
    case 1: case 2:
        printk("    TLB refill of %#x\n", ret * 0x1000);
 
        if ( ret != expect )
            xtf_failure("    Fail: Expected mapping %#x to have been refilled\n",
                        expect * 0x1000);
        break;
 
    case 3:
        printk("    TLB refill of both 0x1000 and 0x2000\n");
        break;
 
    default:
        return xtf_failure("    Fail: Unexpected return value %u\n", ret);
    }
}
 
static const struct tlb_refill_fs_test
{
    const char *desc;
    unsigned int mapping;
    user_desc seg;
 
} tlb_refill_fs_tests[] =
{
    { "(base 0x0)", 1,
      INIT_GDTE_SYM(0, 0xfffff, P, S, G, A, DATA, DPL0, B, W),
    },
 
    { "(base 0x0, limit 0x1)", 1,
      INIT_GDTE_SYM(0, 1, P, S, A, DATA, DPL0, B, W),
    },
 
    { "(base 0x1000)", 2,
      INIT_GDTE_SYM(0x1000, 0xfffff, P, S, G, A, DATA, DPL0, B, W),
    },
 
    { "(base 0x1000, limit 0x1001)", 2,
      INIT_GDTE_SYM(0x1000, 0x1001, P, S, A, DATA, DPL0, B, W),
    },
};
 
static void test_tlb_refill(void)
{
    unsigned int i;
 
    printk("Testing 'invlpg 0x1000' with segment bases\n");
 
    printk("  Test: No segment\n");
    run_tlb_refill_test(invlpg_refill, 1);
 
    for ( i = 0; i < ARRAY_SIZE(tlb_refill_fs_tests); ++i )
    {
        const struct tlb_refill_fs_test *t = &tlb_refill_fs_tests[i];
 
        printk("  Test: %%fs %s\n", t->desc);
        update_desc(&gdt[GDTE_AVAIL0], t->seg);
        write_fs(GDTE_AVAIL0 << 3);
        run_tlb_refill_test(invlpg_fs_refill, t->mapping);
    }
}
 
static void invlpg_checked(unsigned long linear)
{
    asm volatile (_ASM_MAYBE_XEN_FEP
                  "1: invlpg (%0); 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                  :: "r" (linear), [hnd] "p" (ex_fail));
}
 
static void invlpg_fs_checked(unsigned long linear)
{
    asm volatile (_ASM_MAYBE_XEN_FEP
                  "1: invlpg %%fs:(%0); 2:"
                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                  :: "r" (linear), [hnd] "p" (ex_fail));
}
 
static void test_no_fault(void)
{
    printk("Testing 'invlpg' in normally-faulting conditions\n");
 
    printk("  Test: Mapped address\n");
    invlpg_checked(_u(test_main));
 
    printk("  Test: Unmapped address\n");
    invlpg_checked(0);
 
    printk("  Test: NULL segment override\n");
    write_fs(0);
    invlpg_fs_checked(0);
 
    printk("  Test: Past segment limit\n");
    update_desc(&gdt[GDTE_AVAIL0], GDTE_SYM(0, 1, COMMON, DATA, DPL0, B, W));
    write_fs(GDTE_AVAIL0 << 3);
    invlpg_fs_checked(0x2000);
 
    printk("  Test: Before expand-down segment limit\n");
    update_desc(&gdt[GDTE_AVAIL0], GDTE_SYM(0, 1, COMMON, DATA, DPL0, B, W, E));
    write_fs(GDTE_AVAIL0 << 3);
    invlpg_fs_checked(0);
 
#if CONFIG_PAGING_LEVELS >= 4
    printk("  Test: Noncanonical address\n");
    invlpg_checked(0x800000000000ULL);
 
    printk("  Test: Noncanonical including segment base\n");
    write_fs(0);
    wrmsr(MSR_FS_BASE, (1UL << 47) - 1);
    invlpg_fs_checked((1UL << 47) - 1);
#endif
}
 
void test_main(void)
{
    if ( CONFIG_PAGING_LEVELS > 0 )
        test_tlb_refill();
    test_no_fault();
 
    xtf_success(NULL);
}
 
/*
 * Local variables:
 * mode: C
 * c-file-style: "BSD"
 * c-basic-offset: 4
 * tab-width: 4
 * indent-tabs-mode: nil
 * End:
 */