test/termination/kernel/dispatchcheck.rad 5.9 KiB raw
1
//! Native exit and fault reporting to a surviving parent.
2
export mod inputs;
3
export mod cases;
4
5
use kernel::fixture;
6
use kernel::state;
7
use kernel::abi;
8
use kernel::pages;
9
use kernel::capability;
10
use kernel::domains;
11
use kernel::dispatch;
12
use kernel::boot;
13
use kernel::events;
14
use kernel::sync;
15
use kernel::devices;
16
use kernel::platform;
17
18
/// Number of child scenarios, in CPU-window order.
19
constant COUNT: u32 = 6;
20
/// Delay before the first child window, in machine timer ticks.
21
constant START_DELAY: u64 = 1000000;
22
/// Duration of each child and checker window, in machine timer ticks.
23
constant WINDOW_TICKS: u64 = 2000000;
24
25
/// One stimulus and its expected terminal event.
26
record Scenario: Copy {
27
    /// User action and capability configuration.
28
    scenario: cases::Scenario,
29
    /// Expected lifecycle event kind.
30
    kind: u16,
31
    /// Expected exit status or fault code.
32
    code: u32,
33
}
34
35
/// Scenarios in the order in which their CPU windows execute.
36
static SCENARIOS: [Scenario; COUNT] = [
37
    Scenario {
38
        scenario: cases::Scenario::Exit, kind: events::CHILD_EXIT, code: cases::EXIT_STATUS
39
    },
40
    Scenario {
41
        scenario: cases::Scenario::Abort, kind: events::FAULT, code: abi::FAULT_ABORT
42
    },
43
    Scenario {
44
        scenario: cases::Scenario::Breakpoint, kind: events::FAULT, code: cases::BREAKPOINT_CAUSE
45
    },
46
    Scenario {
47
        scenario: cases::Scenario::DestroySelf, kind: events::CHILD_EXIT, code: 0
48
    },
49
    Scenario {
50
        scenario: cases::Scenario::InvalidSelfQuery, kind: events::FAULT, code: abi::FAULT_ABORT
51
    },
52
    Scenario {
53
        scenario: cases::Scenario::DeviceQuery, kind: events::CHILD_EXIT, code: cases::DEVICE_STATUS
54
    },
55
];
56
57
// State retained across setup and verification is initialized before
58
// dispatch starts. The scheduled checker reads it after the user workload.
59
/// Bootstrap creation, allocation, and budget authority.
60
unsafe static TABLE: capability::Table = undefined;
61
/// Child domain identities retained by terminal events.
62
unsafe static CHILDREN: [fixture::Actor; COUNT] = undefined;
63
/// Surviving event receiver and native completion checker.
64
unsafe static PARENT: fixture::Actor = undefined;
65
/// Map a validated physical page.
66
fn memory(address: u64) -> *mut u8;
67
/// Current kernel package-state base.
68
fn kernelGp() -> u64;
69
/// Native entry for the completion checker.
70
fn completion() -> u64;
71
/// Signal successful completion to the machine fixture.
72
fn finish();
73
74
/// Give each child a disjoint window, followed by the surviving parent.
75
export unsafe fn setup() {
76
    let authority = fixture::bootstrap(&mut TABLE);
77
    let image = fixture::load(&mut TABLE, authority, &inputs::INPUT[..]);
78
    set PARENT = fixture::create(&mut TABLE, authority, image);
79
    let parentHandle = PARENT.handle;
80
    fixture::machine(PARENT.domain, completion(), kernelGp());
81
    for i in 0 .. COUNT {
82
        let actor = fixture::create(&mut TABLE, authority, image);
83
        let handle = actor.handle;
84
        let object = actor.domain;
85
        let mut child = try! domains::get(&state::SHARED.domains, object);
86
        let scenario = SCENARIOS[i].scenario;
87
        set CHILDREN[i] = actor;
88
        try! domains::reparent(
89
            &mut state::SHARED.domains, &TABLE, handle, parentHandle
90
        );
91
        let moved = fixture::stack(
92
            &mut TABLE, authority, &mut child.memory.table
93
        );
94
        // The Exit scenario has no arguments. The others read a case and a
95
        // device handle.
96
        let mut args = abi::Handle(0);
97
        let mut size: u64 = 0;
98
        if scenario <> cases::Scenario::Exit {
99
            let page = try! pages::allocate(
100
                &mut state::SHARED.pages, &mut TABLE, authority, 1
101
            );
102
            let storage = try! pages::get(
103
                &state::SHARED.pages, (try! capability::get(&TABLE, page)).object
104
            );
105
            let words = @sliceOf(memory(storage.base) as *mut u64, 2);
106
            set words[0] = scenario as u64;
107
            if scenario == cases::Scenario::DeviceQuery {
108
                let mut installed = false;
109
                for index in 0 .. state::SHARED.devices.count {
110
                    if state::SHARED.devices.regions[index].kind
111
                        <> platform::Kind::Finish
112
                    {
113
                        continue;
114
                    }
115
                    let device = try! devices::install(
116
                        &state::SHARED.devices, &mut child.memory.table, index
117
                    );
118
                    set words[1] = *device;
119
                    set installed = true;
120
                    break;
121
                }
122
                assert installed;
123
            }
124
            set args = try! pages::grant(
125
                &mut state::SHARED.pages, &TABLE, &mut child.memory.table, page, abi::READ as u64
126
            );
127
            set size = 16;
128
        }
129
        try! fixture::activate(&TABLE, handle, moved, args, size);
130
    }
131
    let timer = try! dispatch::timer(&boot::PLATFORM, 0);
132
    let clock = dispatch::now(timer);
133
    fixture::schedule(
134
        &mut TABLE, &CHILDREN[..], PARENT, clock + START_DELAY, WINDOW_TICKS, clock
135
    );
136
}
137
138
/// Check each terminal kind, status, and generation while the parent continues
139
/// to run.
140
export unsafe fn verify() {
141
    let guard = sync::enter();
142
    let mut parent = try! domains::get(&state::SHARED.domains, PARENT.domain);
143
    for scenario, i in &SCENARIOS[..] {
144
        let actor = CHILDREN[i];
145
        let event = try! events::pop(&mut parent.memory.ring)
146
            else panic "verify: missing termination event";
147
        assert event.value == abi::id(actor.domain);
148
        assert event.code == scenario.code and event.kind == scenario.kind;
149
        assert state::SHARED.domains.records[actor.domain.index].state
150
            == domains::Lifecycle::Dead;
151
    }
152
    try! events::refresh(
153
        &mut state::SHARED.domains.events, PARENT.domain, &parent.memory.ring
154
    );
155
    assert try! events::pop(&mut parent.memory.ring) == nil;
156
    sync::leave(guard);
157
    finish();
158
}