//! Native root construction, exit, and continued resource authority.

use kernel::abi;

use kernel::boot;

use kernel::registry;

use kernel::domains;

use kernel::capability;

use kernel::pages;

use kernel::budgets;

use kernel::dispatch;

use kernel::calls;

use kernel::events;

use kernel::sync;

use kernel::startup;

use kernel::devices;

use kernel::interrupts;

/// Initial root identity retained by the terminal event.

unsafe static ROOT: abi::Ref = undefined;

/// Surviving controller domain with inherited resource authority.

unsafe static CONTROLLER: abi::Ref = undefined;

/// Image capability installed in the controller's own table.

unsafe static IMAGE: abi::Handle = undefined;

/// Current kernel package-state table.

fn kernelGp() -> u64;

/// Controller entry address.

fn completion() -> u64;

/// Signal successful completion to the emulator.

fn finish();

/// Map an assembly-compatible physical byte address.

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

/// Construct root from the boot catalog and give its child a later CPU window.

export unsafe fn setup() {

    let image = registry::find(&registry::STORE, &"loaded"[..]) else panic "missing boot user package";

    let service = registry::find(&registry::STORE, &"service"[..]) else panic "missing boot service package";

    set ROOT = try! startup::create(&boot::PLATFORM, image, service);

    assert ROOT.index == 0;

    let mut root = try! domains::get(&domains::STORE, ROOT);

    let self = try! abi::handle(abi::Kind::Domain, abi::Ref { index: 0, generation: root.memory.table.slots[0].generation });

    assert (try! abi::decode(root.events)).object.index == 1;

    let executable = try! registry::install(&registry::STORE, &mut root.memory.table, image);

    let childHandle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings,

        &registry::STORE, &mut root.memory.table, self, executable);

    set CONTROLLER = (try! capability::get(&root.memory.table, childHandle)).object;

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

    let inherited = domains::MANAGEMENT_RIGHTS | abi::CREATE | abi::ALLOCATE;

    let authority = try! calls::invoke(ROOT, 10, &[*childHandle, *childHandle, inherited as u64, 0], 0);

    assert service.index == 3 and image.index == 2;

    set IMAGE = try! registry::install(&registry::STORE, &mut child.memory.table, service);

    try! domains::reparent(&mut domains::STORE, &root.memory.table, self, childHandle);

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

    let frame = &mut domains::STORE.contexts[child.initial.index].frame;

    set frame.pc = completion(); set frame.status = 0x1880;

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

    set frame.registers[3] = kernelGp();

    let now = dispatch::clock();

    let index = 2 + devices::STORE.count + interrupts::STORE.count;

    let budget = try! abi::handle(abi::Kind::Budget, abi::Ref { index, generation: root.memory.table.slots[index].generation });

    let window = try! budgets::query(&budgets::STORE, &root.memory.table, budget);

    let start = window.start;

    let later = try! budgets::split(&mut budgets::STORE, &mut root.memory.table, budget, start + 10000000, now);

    let running = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut root.memory.table,

        budgets::Binding { budget, domain: self, context: root.initial }, now);

    let transferred = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut root.memory.table,

        budgets::Binding { budget: later, domain: childHandle, context: child.initial }, now);

}

/// Root exit leaves the survivor able to allocate and create new domains.

export unsafe fn verify() {

    let guard = sync::enter();

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

    let terminal = try! events::pop(&mut child.memory.ring) else panic "missing root exit";

    assert terminal.kind == events::CHILD_EXIT and terminal.code == 0 and terminal.value == abi::id(ROOT);

    assert child.state == domains::Lifecycle::Active and child.parent == nil;

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

    sync::leave(guard);

    let page = abi::Handle(try! calls::synchronized(CONTROLLER, 30, &[0, 1, 0, 0], dispatch::clock()));

    let domain = abi::Handle(try! calls::synchronized(CONTROLLER, 20, &[0, *IMAGE, 0, 0], dispatch::clock()));

    let checking = sync::enter();

    let allocated = try! capability::get(&child.memory.table, page);

    assert (try! pages::get(&pages::STORE, allocated.object)).count == 1;

    let object = (try! capability::get(&child.memory.table, domain)).object;

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

    assert created.creator == CONTROLLER and created.parent == CONTROLLER;

    assert created.state == domains::Lifecycle::Pending;

    sync::leave(checking);

    finish();

}