test/bootstrap/kernel/dispatchcheck.rad 5.5 KiB raw
1
//! Native root construction, exit, and continued resource authority.
2
use kernel::fixture;
3
use kernel::state;
4
use kernel::abi;
5
use kernel::boot;
6
use kernel::registry;
7
use kernel::domains;
8
use kernel::capability;
9
use kernel::pages;
10
use kernel::budgets;
11
use kernel::dispatch;
12
use kernel::calls;
13
use kernel::events;
14
use kernel::sync;
15
use kernel::startup;
16
17
/// Duration of the root execution window before the surviving checker.
18
constant ROOT_TICKS: u64 = 10000000;
19
20
// State retained across setup and verification is initialized before
21
// dispatch starts. The scheduled checker reads it after the user workload.
22
/// Initial root identity retained by the terminal event.
23
unsafe static ROOT: abi::Ref = undefined;
24
/// Surviving controller domain with inherited resource authority.
25
unsafe static CONTROLLER: abi::Ref = undefined;
26
/// Image capability installed in the controller's own table.
27
unsafe static IMAGE: abi::Handle = undefined;
28
/// Current kernel package-state table.
29
fn kernelGp() -> u64;
30
/// Controller entry address.
31
fn completion() -> u64;
32
/// Signal successful completion to the emulator.
33
fn finish();
34
/// Map an assembly-compatible physical byte address.
35
fn memory(address: u64) -> *mut u8;
36
37
/// Construct root from the boot catalog and give its child a later CPU window.
38
export unsafe fn setup() {
39
    let image = registry::find(
40
        &registry::capture(&state::SHARED.registry), &"loaded"[..]
41
    ) else panic "setup: missing boot user package";
42
    let service = registry::find(
43
        &registry::capture(&state::SHARED.registry), &"service"[..]
44
    ) else panic "setup: missing boot service package";
45
    set ROOT = try! startup::create(
46
        &boot::PLATFORM, &mut state::SHARED, image, service
47
    );
48
    assert ROOT.index == 0;
49
    let mut root = try! domains::get(&state::SHARED.domains, ROOT);
50
    let self = try! abi::handle(abi::Kind::Domain, abi::Ref {
51
        index: 0, generation: root.memory.table.slots[0].generation
52
    });
53
    assert (try! abi::decode(root.events)).object.index == 1;
54
    let executable = try! registry::install(
55
        &state::SHARED.registry, &mut root.memory.table, image
56
    );
57
    let childHandle = try! domains::create(
58
        &mut state::SHARED.domains,
59
        &mut state::SHARED.pages.backings,
60
        &state::SHARED.registry,
61
        &mut root.memory.table,
62
        self,
63
        executable
64
    );
65
    set CONTROLLER =
66
        (try! capability::get(
67
            &root.memory.table, childHandle
68
        )).object;
69
    let mut child = try! domains::get(&state::SHARED.domains, CONTROLLER);
70
    let inherited = domains::MANAGEMENT_RIGHTS | abi::CREATE | abi::ALLOCATE;
71
    let authority = try! calls::invoke(
72
        ROOT,
73
        abi::Operation::CapabilityGrant as u32,
74
        &[
75
            *childHandle, *childHandle,
76
            inherited as u64, 0,
77
        ],
78
        0
79
    );
80
    assert service.index == 3 and image.index == 2;
81
    set IMAGE = try! registry::install(
82
        &state::SHARED.registry, &mut child.memory.table, service
83
    );
84
    try! domains::reparent(
85
        &mut state::SHARED.domains, &root.memory.table, self, childHandle
86
    );
87
    fixture::machine(CONTROLLER, completion(), kernelGp());
88
    let now = dispatch::clock();
89
    let index = 2
90
        + state::SHARED.devices.count
91
        + state::SHARED.interrupts.count;
92
    let budget = try! abi::handle(abi::Kind::Budget, abi::Ref {
93
        index, generation: root.memory.table.slots[index].generation
94
    });
95
    let window = try! budgets::query(
96
        &state::SHARED.budgets, &root.memory.table, budget
97
    );
98
    let start = window.start;
99
    let later = try! budgets::split(
100
        &mut state::SHARED.budgets, &mut root.memory.table, budget, start + ROOT_TICKS, now
101
    );
102
    let rootContext = root.initial;
103
    let childContext = child.initial;
104
    try! calls::rebind(
105
        &mut state::SHARED,
106
        &mut root.memory.table,
107
        budgets::Binding {
108
            budget, domain: self, context: rootContext
109
        },
110
        now
111
    );
112
    try! calls::rebind(
113
        &mut state::SHARED,
114
        &mut root.memory.table,
115
        budgets::Binding {
116
            budget: later, domain: childHandle, context: childContext
117
        },
118
        now
119
    );
120
}
121
122
/// Root exit leaves the survivor able to allocate and create new domains.
123
export unsafe fn verify() {
124
    let guard = sync::enter();
125
    let mut child = try! domains::get(&state::SHARED.domains, CONTROLLER);
126
    let terminal = try! events::pop(&mut child.memory.ring) else panic "verify: missing root exit";
127
    assert terminal.kind == events::CHILD_EXIT
128
        and terminal.code == 0
129
        and terminal.value == abi::id(ROOT);
130
    assert child.state == domains::Lifecycle::Active and child.parent == nil;
131
    try! events::refresh(
132
        &mut state::SHARED.domains.events, CONTROLLER, &child.memory.ring
133
    );
134
    sync::leave(guard);
135
    let page = abi::Handle(try! calls::synchronized(
136
        CONTROLLER, abi::Operation::PageAllocate as u32, &[0, 1, 0, 0], dispatch::clock()
137
    ));
138
    let domain = abi::Handle(try! calls::synchronized(
139
        CONTROLLER, abi::Operation::DomainCreate as u32, &[0, *IMAGE, 0, 0], dispatch::clock()
140
    ));
141
    let checking = sync::enter();
142
    let allocated = try! capability::get(&child.memory.table, page);
143
    assert (try! pages::get(&state::SHARED.pages, allocated.object)).count == 1;
144
    let object = (try! capability::get(&child.memory.table, domain)).object;
145
    let created = try! domains::get(&state::SHARED.domains, object);
146
    assert created.creator == CONTROLLER and created.parent == CONTROLLER;
147
    assert created.state == domains::Lifecycle::Pending;
148
    sync::leave(checking);
149
    finish();
150
}