//! Native exit and fault reporting to a surviving parent.

use std::mem;

use kernel::abi;

use kernel::slots;

use kernel::backing;

use kernel::pages;

use kernel::capability;

use kernel::registry;

use kernel::loader;

use kernel::domains;

use kernel::budgets;

use kernel::dispatch;

use kernel::boot;

use kernel::events;

use kernel::sync;

use kernel::dispatchinput;

use kernel::devices;

use kernel::platform;

/// Bootstrap creation, allocation, and budget authority.

unsafe static TABLE: capability::Table = undefined;

/// Child domain identities retained by terminal events.

unsafe static CHILDREN: [abi::Ref; 6] = undefined;

/// Surviving event receiver and native completion checker.

unsafe static PARENT: abi::Ref = undefined;

/// Map a validated physical page.

fn memory(address: u64) -> *mut u8;

/// Current kernel package-state base.

fn kernelGp() -> u64;

/// Native entry for the completion checker.

fn completion() -> u64;

/// Signal successful completion to the machine fixture.

fn finish();

/// Give each child a disjoint window, followed by the surviving parent.

export unsafe fn setup() {

    let pending = try! slots::reserve(&mut domains::STORE.slots[..]);

    let owner = try! slots::commit(&mut domains::STORE.slots[..], pending);

    capability::initialize(&mut TABLE, owner);

    try! backing::registerDomain(&mut pages::STORE.backings, owner);

    let authority = try! capability::install(&mut TABLE, capability::Entry {

        kind: abi::Kind::Domain, object: owner, rights: abi::Rights(abi::CREATE | abi::ALLOCATE),

    });

    let source = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, (dispatchinput::INPUT.len as u64 + 4095) / 4096);

    let page = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, source)).object);

    let bytes = @sliceOf(memory(page.base), page.count * 4096);

    let length = try! mem::copy(&mut bytes[..], &dispatchinput::INPUT[..]);

    let image = try! loader::load(&mut loader::STATE, &mut pages::STORE, &mut registry::STORE, &mut TABLE,

        loader::Request { authority, source, offset: 0, length: length as u64 });

    let parentHandle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, image);

    set PARENT = (try! capability::get(&TABLE, parentHandle)).object;

    let parent = try! domains::get(&domains::STORE, PARENT);

    set domains::STORE.records[PARENT.index].state = domains::Lifecycle::Active;

    set domains::STORE.contexts[parent.initial.index].frame.pc = completion();

    set domains::STORE.contexts[parent.initial.index].frame.status = 0x1880;

    set domains::STORE.contexts[parent.initial.index].frame.registers[2] = domains::STORE.contexts[parent.initial.index].kernelStack.end;

    set domains::STORE.contexts[parent.initial.index].frame.registers[3] = kernelGp();

    let mut handles: [abi::Handle; 6] = undefined;

    let mut contexts: [abi::Ref; 6] = undefined;

    for i in 0..6 {

        let handle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, image);

        let object = (try! capability::get(&TABLE, handle)).object;

        let mut child = try! domains::get(&domains::STORE, object);

        set CHILDREN[i] = object;

        set handles[i] = handle;

        set contexts[i] = child.initial;

        try! domains::reparent(&mut domains::STORE, &TABLE, handle, parentHandle);

        let stack = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, 1);

        let granted = try! pages::grant(&mut pages::STORE, &TABLE, &mut child.memory.table, stack, (abi::READ | abi::WRITE) as u64);

        let storage = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, stack)).object);

        let mut size = i as u64;

        if i == 5 {

            let mut installed = false;

            for index in 0..devices::STORE.count {

                if devices::STORE.regions[index].kind <> platform::Kind::Finish {

                    continue;

                }

                let device = try! devices::install(&devices::STORE, &mut child.memory.table, index);

                let args = memory(storage.base) as *mut u64;

                set *args = *device;

                set installed = true;

                break;

            }

            assert installed;

            set size = 8;

        }

        try! domains::activate(&mut domains::STORE, &pages::STORE, &TABLE, handle, storage.base + 4096, storage.base, size);

    }

    let timer = try! dispatch::timer(&boot::PLATFORM, 0);

    let clock = dispatch::now(timer);

    let start = clock + 1000000;

    let mut remaining = try! budgets::seed(&mut budgets::STORE, &mut TABLE, 0, start, start + 14000000);

    for i in 0..6 {

        let next = try! budgets::split(&mut budgets::STORE, &mut TABLE, remaining, start + (i as u64 + 1) * 2000000, clock);

        let bound = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut TABLE,

            budgets::Binding { budget: remaining, domain: handles[i], context: contexts[i] }, clock);

        set remaining = next;

    }

    let bound = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut TABLE,

        budgets::Binding { budget: remaining, domain: parentHandle, context: parent.initial }, clock);

}

/// Check each terminal kind, status, and generation while the parent continues to run.

export unsafe fn verify() {

    let guard = sync::enter();

    let mut parent = try! domains::get(&domains::STORE, PARENT);

    let codes = [37 as u32, abi::FAULT_ABORT, 3, 0, abi::FAULT_ABORT, 51];

    for i in 0..6 {

        let event = try! events::pop(&mut parent.memory.ring) else panic "missing termination event";

        assert event.value == abi::id(CHILDREN[i]) and event.code == codes[i];

        if i == 0 or i == 3 or i == 5 {

            assert event.kind == events::CHILD_EXIT;

        }

        else {

            assert event.kind == events::FAULT;

        }

        assert domains::STORE.records[CHILDREN[i].index].state == domains::Lifecycle::Dead;

    }

    try! events::refresh(&mut domains::STORE.events, PARENT, &parent.memory.ring);

    assert try! events::pop(&mut parent.memory.ring) == nil;

    sync::leave(guard);

    finish();

}