//! Observe user-space bootstrap and scheduling at the trap boundary.

use kernel::abi;

use std::lang::il;

use kernel::trap;

use kernel::dispatch;

use kernel::domains;

use kernel::budgets;

use kernel::events;

use kernel::sync;

/// Root has requested normal termination.

static ROOT_EXITED: bool = false;

/// Workers that returned after root released its authority.

static WORKERS: u32 = 0;

/// Write one byte to the test UART.

fn put(value: u8);

/// Most recent user operation for fault diagnosis.

static LAST_CALL: u64 = 0;

/// Print a complete hexadecimal diagnostic word.

fn number(value: u64) {

    let digits = "0123456789abcdef";

    for i in 0..16 { put(digits[((value >> ((15 - i) as u64 * 4)) & 15) as u32]); }

    put(10);

}

/// Check terminal calls without changing user-domain resources or execution.

export unsafe fn observe(frame: &trap::Frame) {

    if not trap::fromUser(frame) { return; }

    let cause = trap::classify(frame.cause);

    if cause == trap::Cause::Timer or cause == trap::Cause::Software or cause == trap::Cause::External { return; }

    if cause <> trap::Cause::UserCall {

        number(frame.cause); number(frame.pc); number(LAST_CALL); number(WORKERS as u64);

        assert false;

    }

    set LAST_CALL = frame.registers[17];

    assert frame.registers[17] <> abi::Operation::Abort as u64;

    let shutdown = frame.registers[17] == il::DEVICE_ACCESS as u64 and frame.registers[12] == 0x104;

    if frame.registers[17] <> abi::Operation::Exit as u64 and not shutdown { return; }

    let current = dispatch::current();

    let context = abi::reference(current.context);

    let guard = sync::enter();

    let owner = domains::STORE.contexts[context.index].owner;

    if owner.index == 0 {

        assert frame.registers[10] == 0;

        set ROOT_EXITED = true;

    } else if owner.index == 1 {

        assert ROOT_EXITED and WORKERS == 4 and shutdown and frame.registers[13] == 0x5555;

        let scheduler = try! domains::get(&domains::STORE, owner);

        assert scheduler.parent == nil;

        let ring = &scheduler.memory.ring;

        assert ring.tail - ring.head == 5;

        assert ring.data[ring.head & ring.mask].kind == events::CHILD_EXIT;

        assert ring.data[ring.head & ring.mask].code == 0;

        for i in 1..5 {

            let event = ring.data[(ring.head + i) & ring.mask];

            assert event.kind == events::CHILD_EXIT and event.code == 7;

        }

        let future = try! budgets::query(&budgets::STORE, &scheduler.memory.table, abi::Handle(current.budget));

        assert future.end > dispatch::clock();

        sync::leave(guard);

        return;

    } else {

        assert ROOT_EXITED and frame.registers[10] == 7;

        set WORKERS += 1;

    }

    sync::leave(guard);

}