//! Initial resource handoff to the user-space scheduler.

export mod abi;

export mod sys;

/// Root startup memory supplied by the kernel.

record Env: Copy {

    /// Writable header and copied resource handles.

    argsPointer: *unsafe mut abi::BootInfo,

    /// Header size in bytes.

    argsSize: u64,

    /// Root's event capability.

    eventsHandle: u64,

    /// Root's event-ring address.

    eventsPointer: u64,

}

/// Transfer root's resource bundle and parent duties before normal exit.

@default unsafe fn main(env: *Env) -> ! {

    assert env.argsSize == @sizeOf(abi::BootInfo) as u64;

    let mut info = env.argsPointer;

    let self = abi::Handle(info.handles[0]);

    let scheduler = try! sys::domainCreate(self, info.schedulerImage);

    let context = try! sys::queryContext(scheduler, 0);

    let authority = try! sys::capabilityGrant(scheduler, scheduler, abi::RIGHTS_MASK as u64);

    let stack = try! sys::pageAllocate(self, 16);

    let stackInfo = sys::queryPage(stack);

    let sharedStack = try! sys::capabilityTransfer(stack, scheduler, abi::RIGHTS_MASK as u64);

    let mut handles = info.handles;

    let clock = info.clock;

    let shutdown = info.shutdown;

    let budgets = 2 + info.devices as u32 + info.interrupts as u32;

    for i in 2..budgets {

        let old = abi::Handle(handles[i]);

        let moved = try! sys::capabilityTransfer(old, scheduler, abi::RIGHTS_MASK as u64);

        set handles[i] = *moved;

        if old == clock {

            set info.clock = moved;

        }

        if old == shutdown {

            set info.shutdown = moved;

        }

    }

    for i in budgets..handles.len {

        let budget = abi::Handle(handles[i]);

        let window = try! sys::queryBudget(budget);

        if window.hart == 0 {

            let future = try! sys::budgetSplit(budget, window.start + info.timebase * 2);

            set handles[i] = *try! sys::budgetBind(future, scheduler, context.context);

        } else {

            set handles[i] = *try! sys::capabilityTransfer(budget, scheduler, abi::RIGHTS_MASK as u64);

        }

    }

    set info.rootImage = try! sys::capabilityTransfer(info.rootImage, scheduler, abi::RIGHTS_MASK as u64);

    set info.schedulerImage = try! sys::capabilityTransfer(info.schedulerImage, scheduler, abi::RIGHTS_MASK as u64);

    set info.arguments = try! sys::capabilityTransfer(info.arguments, scheduler, abi::RIGHTS_MASK as u64);

    set handles[0] = *authority;

    set handles[1] = 0;

    try! sys::domainReparent(self, scheduler);

    try! sys::domainActivate(scheduler, stackInfo.base + stackInfo.count * 4096,

        info as *unsafe opaque, @sizeOf(abi::BootInfo) as u64);

    sys::exit(0);

}