main.c

Go to the documentation of this file.

#include <xtf.h>

#include "lowlevel.h"

const char test_title[] = "Software interrupt emulation";

bool test_wants_user_mappings = true;

struct single
{
    const char *type;
    void (*fn)(void);
    void *trap, *fault;
};

struct sequence
{
    const char *name;
    struct single tests[4];
};

struct sequence int3 =
{ "int3",
  {
      {"regular", stub_int3_reg,
       label_int3_reg_trap, label_int3_reg_fault},

      {"redundant", stub_int3_red,
       label_int3_red_trap, label_int3_red_fault},

      {"forced", stub_int3_force,
       label_int3_force_trap, label_int3_force_fault},

      {"forced redundant", stub_int3_forcered,
       label_int3_forcered_trap, label_int3_forcered_fault},
  },
};

struct sequence int_0x3 =
{ "int $3",
  {
      {"regular", stub_int_0x3_reg,
       label_int_0x3_reg_trap, label_int_0x3_reg_fault},

      {"redundant", stub_int_0x3_red,
       label_int_0x3_red_trap, label_int_0x3_red_fault},

      {"forced", stub_int_0x3_force,
       label_int_0x3_force_trap, label_int_0x3_force_fault},

      {"forced redundant", stub_int_0x3_forcered,
       label_int_0x3_forcered_trap, label_int_0x3_forcered_fault},
  },
};

struct sequence icebp =
{ "icebp",
  {
      {"regular", stub_icebp_reg,
       label_icebp_reg_trap, label_icebp_reg_fault},

      {"redundant", stub_icebp_red,
       label_icebp_red_trap, label_icebp_red_fault},

      {"forced", stub_icebp_force,
       label_icebp_force_trap, label_icebp_force_fault},

      {"forced redundant", stub_icebp_forcered,
       label_icebp_forcered_trap, label_icebp_forcered_fault},
  },
};

struct sequence int_0x1 =
{ "int $1",
  {
      {"regular", stub_int_0x1_reg,
       label_int_0x1_reg_trap, label_int_0x1_reg_fault},

      {"redundant", stub_int_0x1_red,
       label_int_0x1_red_trap, label_int_0x1_red_fault},

      {"forced", stub_int_0x1_force,
       label_int_0x1_force_trap, label_int_0x1_force_fault},

      {"forced redundant", stub_int_0x1_forcered,
       label_int_0x1_forcered_trap, label_int_0x1_forcered_fault},
  },
};

struct sequence into =
{ "into",
  {
      {"regular", stub_into_reg,
       label_into_reg_trap, label_into_reg_fault},

      {"redundant", stub_into_red,
       label_into_red_trap, label_into_red_fault},

      {"forced", stub_into_force,
       label_into_force_trap, label_into_force_fault},

      {"forced redundant", stub_into_forcered,
       label_into_forcered_trap, label_into_forcered_fault},
  },
};

static bool user = false;

struct expectation {
    const char *prefix;
    const void *ip;
    unsigned int ev, ec;
} 
    expectation;

void expect(const void *prefix, const void *ip,
            unsigned int ev, unsigned int ec)
{
    expectation = (struct expectation){prefix, ip, ev, ec};
    xtf_exlog_reset();
}

void check(void)
{
    unsigned int entries = xtf_exlog_entries();

    if ( entries != 1 )
    {
        xtf_failure("Fail %s: Expected 1 exception (vec %u at %p), got %u\n",
                    expectation.prefix, expectation.ev,
                    expectation.ip, entries);
        xtf_exlog_dump_log();
        return;
    }

    exlog_entry_t *entry = xtf_exlog_entry(0);
    if ( !entry )
    {
        xtf_failure("Fail %s: Unable to retrieve exception log\n",
                    expectation.prefix);
        return;
    }

    if ( (_p(entry->ip) != expectation.ip) ||
         (entry->ev != expectation.ev) ||
         (entry->ec != expectation.ec) )
    {
        xtf_failure("Fail %s:\n"
                    "  Expected vec %2u[%04x] at %p\n"
                    "       got vec %2u[%04x] at %p\n",
                    expectation.prefix,
                    expectation.ev, expectation.ec, expectation.ip,
                    entry->ev, entry->ec, _p(entry->ip));
        return;
    }
}

bool do_unhandled_exception(struct cpu_regs *regs)
{
    printk("Unhandled Exception at %p\n", _p(regs));
    check();

    return false;
}

void test_seq(struct sequence *seq, unsigned int vector,
              unsigned int error, bool fault)
{
    unsigned int i;

    printk("  Testing %s\n", seq->name);

    for ( i = 0; i < ARRAY_SIZE(seq->tests); ++i )
    {
        struct single *s = &seq->tests[i];

        expect(s->type,
               fault ? s->fault : s->trap,
               vector, error);

        user ? exec_user_void(s->fn) : s->fn();

        check();

        /* Avoid 'force' and 'forcered' stubs if FEP isn't available. */
        if ( i == 1 && !xtf_has_fep )
            break;
    }
}

static void test_trap(struct sequence *seq, unsigned int vector)
{
    test_seq(seq, vector, 0, false);
}

static void test_fault(struct sequence *seq,
                       unsigned int vector, unsigned int error)
{
    test_seq(seq, vector, error, true);
}

static void set_idt_entries_present(bool present)
{
    idt[X86_EXC_DB].p = present;
    idt[X86_EXC_BP].p = present;
    idt[X86_EXC_OF].p = present;
}

static void set_idt_entries_dpl(unsigned int dpl)
{
    idt[X86_EXC_DB].dpl = dpl;
    idt[X86_EXC_BP].dpl = dpl;
    idt[X86_EXC_OF].dpl = dpl;
}

void cpl3_tests(void)
{
    user = true;

    printk("Test cpl3: all perms ok\n");
    {
        test_trap(&int3,    X86_EXC_BP);
        test_trap(&int_0x3, X86_EXC_BP);
        test_trap(&icebp,   X86_EXC_DB);
        test_trap(&int_0x1, X86_EXC_DB);
#ifdef __i386__
        test_trap(&into,    X86_EXC_OF);
#else
        test_fault(&into,   X86_EXC_UD, 0);
#endif
    }

    printk("Test cpl3: p=0\n");
    {
        set_idt_entries_present(false);

        test_fault(&int3,    X86_EXC_NP, EXC_EC_SYM(BP));
        test_fault(&int_0x3, X86_EXC_NP, EXC_EC_SYM(BP));
        test_fault(&icebp,   X86_EXC_NP, EXC_EC_SYM(DB, EXT));
        test_fault(&int_0x1, X86_EXC_NP, EXC_EC_SYM(DB));
#ifdef __i386__
        test_fault(&into,    X86_EXC_NP, EXC_EC_SYM(OF));
#else
        test_fault(&into,    X86_EXC_UD, 0);
#endif

        set_idt_entries_present(true);
    }

    printk("Test cpl3: dpl=0\n");
    {
        set_idt_entries_dpl(0);

        test_fault(&int3,    X86_EXC_GP, EXC_EC_SYM(BP));
        test_fault(&int_0x3, X86_EXC_GP, EXC_EC_SYM(BP));
         /* icebp count as external, so no dpl check. */
        test_trap (&icebp,   X86_EXC_DB);
        test_fault(&int_0x1, X86_EXC_GP, EXC_EC_SYM(DB));
#ifdef __i386__
        test_fault(&into,    X86_EXC_GP, EXC_EC_SYM(OF));
#else
        test_fault(&into,    X86_EXC_UD, 0);
#endif

        set_idt_entries_dpl(3);
    }

    user = false;
}

void cpl0_tests(void)
{
    printk("Test cpl0: all perms ok\n");
    {
        test_trap(&int3,    X86_EXC_BP);
        test_trap(&int_0x3, X86_EXC_BP);
        test_trap(&icebp,   X86_EXC_DB);
        test_trap(&int_0x1, X86_EXC_DB);
#ifdef __i386__
        test_trap(&into,    X86_EXC_OF);
#else
        test_fault(&into,   X86_EXC_UD, 0);
#endif
    }

    printk("Test cpl0: p=0\n");
    {
        set_idt_entries_present(false);

        test_fault(&int3,    X86_EXC_NP, EXC_EC_SYM(BP));
        test_fault(&int_0x3, X86_EXC_NP, EXC_EC_SYM(BP));
        test_fault(&icebp,   X86_EXC_NP, EXC_EC_SYM(DB, EXT));
        test_fault(&int_0x1, X86_EXC_NP, EXC_EC_SYM(DB));
#ifdef __i386__
        test_fault(&into,    X86_EXC_NP, EXC_EC_SYM(OF));
#else
        test_fault(&into,    X86_EXC_UD, 0);
#endif

        set_idt_entries_present(true);
    }
}

void test_main(void)
{
    /*
     * Even if FEP is unavailable, run the tests against real hardware to
     * check the algorithm, but don't claim overall success.
     */
    if ( !xtf_has_fep )
        xtf_skip("FEP support not detected - some tests will be skipped\n");

    set_idt_entries_present(true);
    set_idt_entries_dpl(3);

    xtf_exlog_start();

    cpl0_tests();
    cpl3_tests();

    xtf_exlog_stop();

    xtf_success(NULL);
}

/*
 * Local variables:
 * mode: C
 * c-file-style: "BSD"
 * c-basic-offset: 4
 * tab-width: 4
 * indent-tabs-mode: nil
 * End:
 */