//! User-mode register widths and rejected MMIO authority.

export mod abi;

export mod sys;

export mod mmio;

/// Device values installed in the calling domain's table.

record Arguments: Copy {

    /// Register interface under test.

    device: abi::Handle,

    /// Read-only machine timer.

    clock: abi::Handle,

}

/// Case selection and readable arguments supplied by the test parent.

record Env: Copy {

    /// Installed device handles.

    argsPointer: *Arguments,

    /// Sixteen plus the test case number.

    argsSize: u64,

    /// Installed event capability.

    eventsHandle: u64,

    /// Shared ring address.

    eventsPointer: u64,

}

/// Execute each width, or require a kernel fault before an unauthorized access.

@default fn main(env: *Env) {

    let device = env.argsPointer.device;

    let scenario = env.argsSize - 16;

    if scenario == 0 {

        let before = mmio::read64(env.argsPointer.clock, 0);

        mmio::write8(device, 0, 0x81);

        mmio::write16(device, 2, 0x8123);

        mmio::write32(device, 4, 0x81234567);

        mmio::write64(device, 8, 0x8123456789abcdef);

        assert mmio::read8(device, 0) == 0x81;

        assert mmio::read16(device, 2) == 0x8123;

        assert mmio::read32(device, 4) == 0x81234567;

        assert mmio::read64(device, 8) == 0x8123456789abcdef;

        assert mmio::read32(env.argsPointer.clock, 0) as u64 >= before;

        sys::exit(61);

    }

    if scenario == 1 or scenario == 2 { mmio::write32(device, 0, 0x5555); }

    if scenario == 3 { let value = mmio::read8(device, 0); }

    if scenario == 4 { mmio::write32(device, 1, 1); }

    if scenario == 5 { let value = mmio::read8(device, 4096); }

    if scenario == 6 { try! sys::capabilityDrop(device); mmio::write32(device, 0, 0x5555); }

    if scenario == 7 { let value = mmio::read8(device, 0); }

    if scenario == 8 { mmio::write64(device, 0xfffffffffffffff8, 1); }

    sys::exit(99);

}