test/dispatch/kernel/dispatchcheck.rad 10.7 KiB raw
1
//! Native timer preemption across user execution, idle, and machine
2
//! continuations.
3
export mod inputs;
4
5
use std::arch::rv64::shared;
6
use std::arch::rv64;
7
use kernel::calls;
8
use kernel::fixture;
9
use kernel::state;
10
use kernel::abi;
11
use kernel::pages;
12
use kernel::capability;
13
use kernel::registry;
14
use kernel::instances;
15
use kernel::domains;
16
use kernel::budgets;
17
use kernel::dispatch;
18
use kernel::boot;
19
use kernel::registers;
20
use kernel::events;
21
use kernel::sync;
22
23
/// Number of scheduled fixture actors.
24
constant COUNT: u32 = 3;
25
/// Index of the user-mode workload.
26
constant USER: u32 = 0;
27
/// Index of the retained machine-mode workload.
28
constant WORKER: u32 = 1;
29
/// Index of the final machine checker.
30
constant CHECKER: u32 = 2;
31
32
/// Delay before user dispatch, in machine timer ticks.
33
constant START_DELAY: u64 = 1000000;
34
35
/// Duration of a dispatch span, large enough for user setup calls.
36
constant WINDOW_TICKS: u64 = 32000000;
37
38
// State retained across setup and verification is initialized before
39
// dispatch starts. The scheduled checker reads it after the user workload.
40
/// Bootstrap authority used to create fixture domains and CPU windows.
41
unsafe static TABLE: capability::Table = undefined;
42
/// Domain handles for budget binding and initial contexts for the user,
43
/// machine worker, and completion check.
44
unsafe static ACTORS: [fixture::Actor; COUNT] = undefined;
45
/// View a validated allocated source page.
46
fn memory(address: u64) -> *mut u8;
47
/// Current kernel package-state base.
48
fn kernelGp() -> u64;
49
/// Native entry for retained M-mode work.
50
fn worker() -> u64;
51
/// Native entry for the final assertion callback.
52
fn completion() -> u64;
53
/// Complete the machine fixture with a passing status.
54
fn finish();
55
/// Complete the fixture with a distinct failed invariant code.
56
fn failed(code: u64);
57
58
/// Give the user domain its stack and its arguments Page, which names a Page
59
/// for queries, the package, the self Domain and the completion checker, and
60
/// activate it. The future window is added to the arguments later. Return the
61
/// arguments.
62
unsafe fn startUser(
63
    authority: abi::Handle,
64
    user: &mut domains::Domain,
65
    executable: abi::Handle,
66
    selfAuthority: abi::Handle
67
) -> *mut [u8] {
68
    let moved = fixture::stack(
69
        &mut TABLE, authority, &mut user.memory.table
70
    );
71
    let startup = try! pages::allocate(
72
        &mut state::SHARED.pages, &mut TABLE, authority, 1
73
    );
74
    let granted = try! pages::grant(
75
        &mut state::SHARED.pages, &TABLE, &mut user.memory.table, startup, abi::READ as u64
76
    );
77
    let stackCap = try! capability::get(&TABLE, startup);
78
    let stackPage = try! pages::get(&state::SHARED.pages, stackCap.object);
79
    let checkerContext = ACTORS[CHECKER].context;
80
    let checkerOwner =
81
        state::SHARED.domains.contexts[checkerContext.index].owner;
82
    let parent = try! capability::install(&mut user.memory.table, capability::Entry {
83
        kind: abi::Kind::Domain, object: checkerOwner, rights: abi::Rights(abi::WAKE)
84
    });
85
    let args = @sliceOf(memory(stackPage.base), 40);
86
    let words = [*granted, *executable, *selfAuthority];
87
    for word in 0 .. COUNT {
88
        for byte in 0 .. fixture::WORD_BYTES {
89
            set args[word * 8 + byte] = (words[word] >> (byte as u64 * 8)) as u8;
90
        }
91
    }
92
    for byte in 0 .. fixture::WORD_BYTES {
93
        set args[32 + byte] = (*parent >> (byte as u64 * 8)) as u8;
94
    }
95
    try! fixture::activate(&TABLE, ACTORS[USER].handle, moved, granted, 40);
96
    return args;
97
}
98
99
/// Prepare real private domains before enabling dispatch on hart zero.
100
export unsafe fn setup() {
101
    let authority = fixture::bootstrap(&mut TABLE);
102
    let image = fixture::load(&mut TABLE, authority, &inputs::INPUT[..]);
103
    for i in 0 .. COUNT {
104
        set ACTORS[i] = fixture::create(&mut TABLE, authority, image);
105
        let actor = ACTORS[i];
106
        if i <> USER {
107
            fixture::machine(
108
                actor.domain, worker() if i == WORKER else completion(), kernelGp()
109
            );
110
        }
111
    }
112
    let cap = try! capability::get(&TABLE, ACTORS[USER].handle);
113
    let mut user = try! domains::get(&state::SHARED.domains, cap.object);
114
    let selfAuthority = try! capability::install(&mut user.memory.table, capability::Entry {
115
        kind: abi::Kind::Domain,
116
        object: cap.object,
117
        rights: abi::Rights(
118
            abi::CREATE
119
                | abi::ALLOCATE
120
                | abi::EXECUTE
121
                | abi::WAKE
122
                | abi::DESTROY
123
        ),
124
    });
125
    let root = user.image;
126
    let executable = try! registry::install(
127
        &state::SHARED.registry, &mut user.memory.table, root
128
    );
129
    let args = startUser(authority, &mut user, executable, selfAuthority);
130
    let imageRef = try! registry::image(&state::SHARED.registry, &TABLE, image, abi::Rights(
131
        abi::EXECUTE
132
    ));
133
    let target = try! registry::exported(
134
        &state::SHARED.registry, imageRef, &"spin::count"[..]
135
    );
136
    let case shared::Target::Data(data) = target else panic "setup: counter";
137
    let timer = try! dispatch::timer(&boot::PLATFORM, 0);
138
    let clock = dispatch::now(timer);
139
    let start = clock + START_DELAY;
140
    // The user must finish its setup calls inside the first span, so the span
141
    // is large relative to the kernel work of those calls. `spin::worker` arms
142
    // its timeout for a quarter of the span.
143
    let span: u64 = WINDOW_TICKS;
144
    let workerContext = ACTORS[WORKER].context;
145
    let frame = &mut state::SHARED.domains.contexts[workerContext.index].frame;
146
    set frame.registers[*rv64::A0 as u32] =
147
        instances::base(
148
            &state::SHARED.domains.tables[cap.object.index], data.slot
149
        ) + data.offset as u64;
150
    set frame.registers[*rv64::A1 as u32] = registers::start(timer.window)
151
        + dispatch::CLOCK;
152
    set frame.registers[*rv64::A2 as u32] = start + 3 * span;
153
    set frame.registers[*rv64::A3 as u32] = start + 4 * span;
154
    let mut windows: [abi::Handle; 6] = undefined;
155
    let mut remaining = try! budgets::seed(
156
        &mut state::SHARED.budgets, &mut TABLE, 0, start, start + 6 * span
157
    );
158
    for i in 0 .. 6 {
159
        set windows[i] = remaining;
160
        if i < 5 {
161
            set remaining = try! budgets::split(
162
                &mut state::SHARED.budgets,
163
                &mut TABLE,
164
                remaining,
165
                start + (i as u64 + 1) * span,
166
                clock
167
            );
168
        }
169
    }
170
    let owners = &[USER, USER, WORKER, USER, WORKER, CHECKER];
171
    for i in 0 .. 6 {
172
        // Window 1 is an idle gap. Dispatch retires expired windows through
173
        // their owner's domain table, which the bootstrap table is not, so it
174
        // is dropped.
175
        if i == 1 {
176
            try! budgets::drop(
177
                &mut state::SHARED.budgets, &mut TABLE, windows[i]
178
            );
179
            continue;
180
        }
181
        let owner = owners[i];
182
        let handle = try! calls::rebind(
183
            &mut state::SHARED,
184
            &mut TABLE,
185
            budgets::Binding {
186
                budget: windows[i], domain: ACTORS[owner].handle, context: ACTORS[owner].context
187
            },
188
            clock
189
        );
190
        if i == 3 {
191
            for byte in 0 .. fixture::WORD_BYTES {
192
                set args[24 + byte] = (*handle >> (byte as u64 * 8)) as u8;
193
            }
194
        }
195
    }
196
}
197
198
/// Check state captured by production timer handling after both resumptions.
199
export unsafe fn verify() {
200
    let userContext = ACTORS[USER].context;
201
    let checkerContext = ACTORS[CHECKER].context;
202
    let userOwner = state::SHARED.domains.contexts[userContext.index].owner;
203
    let checkerOwner =
204
        state::SHARED.domains.contexts[checkerContext.index].owner;
205
    let table = &state::SHARED.domains.tables[userOwner.index];
206
    let user = state::SHARED.domains.contexts[userContext.index].frame;
207
    let machine =
208
        state::SHARED.domains.contexts[ACTORS[WORKER].context.index].frame;
209
    assert (user.status & fixture::MACHINE_PRIVILEGE) == 0
210
        and (machine.status & fixture::MACHINE_PRIVILEGE)
211
            == fixture::MACHINE_PRIVILEGE;
212
    assert machine.registers[*rv64::S0 as u32] > 0
213
        and machine.registers[*rv64::S1 as u32] == 1
214
        and machine.registers[*rv64::S2 as u32] > 0;
215
    let mut domain = try! domains::get(&state::SHARED.domains, userOwner);
216
    let target = try! registry::exported(
217
        &state::SHARED.registry, domain.image, &"spin::extraCount"[..]
218
    );
219
    let case shared::Target::Data(data) = target else panic "verify: extra counter";
220
    let bytes = @sliceOf(
221
        memory(
222
            instances::base(
223
                table, data.slot
224
            ) + data.offset as u64
225
        ),
226
        8
227
    );
228
    let mut progress: u64 = 0;
229
    for byte in 0 .. fixture::WORD_BYTES {
230
        set progress |= bytes[byte] as u64 << (byte as u64 * 8);
231
    }
232
    if progress == 0 {
233
        failed(6);
234
    }
235
    let checked = try! registry::exported(
236
        &state::SHARED.registry, domain.image, &"spin::destroyed"[..]
237
    );
238
    let case shared::Target::Data(flag) = checked else panic "verify: destruction flag";
239
    if *memory(instances::base(table, flag.slot) + flag.offset as u64) <> 1 {
240
        failed(7);
241
    }
242
    let child = try! registry::exported(
243
        &state::SHARED.registry, domain.image, &"spin::childId"[..]
244
    );
245
    let case shared::Target::Data(identity) = child else panic "verify: child identity";
246
    let idBytes = @sliceOf(
247
        memory(
248
            instances::base(
249
                table, identity.slot
250
            ) + identity.offset as u64
251
        ),
252
        8
253
    );
254
    let mut childId: u64 = 0;
255
    for byte in 0 .. fixture::WORD_BYTES {
256
        set childId |= idBytes[byte] as u64 << (byte as u64 * 8);
257
    }
258
    let owner = checkerOwner;
259
    let guard = sync::enter();
260
    let mut checker = try! domains::get(&state::SHARED.domains, owner);
261
    assert try! events::flush(
262
        &mut state::SHARED.domains.events, owner, &mut checker.memory.ring
263
    ) == 0;
264
    assert not try! events::acknowledged(&state::SHARED.domains.events, abi::reference(
265
        childId
266
    ));
267
    let exited = try! events::pop(&mut checker.memory.ring) else panic "verify: child exit";
268
    assert exited.kind == events::CHILD_EXIT
269
        and exited.code == 0
270
        and exited.value == childId;
271
    try! events::refresh(
272
        &mut state::SHARED.domains.events, owner, &checker.memory.ring
273
    );
274
    assert try! events::acknowledged(&state::SHARED.domains.events, abi::reference(
275
        childId
276
    ));
277
    sync::leave(guard);
278
    let wake = try! events::pop(&mut domain.memory.ring) else panic "verify: wake token";
279
    assert wake.kind == events::WAKEUP and wake.code == 123;
280
    let timeout = try! events::pop(&mut domain.memory.ring) else panic "verify: timeout token";
281
    assert timeout.kind == events::TIMEOUT
282
        and timeout.code == 77
283
        and timeout.value == 0;
284
    assert try! events::pop(&mut domain.memory.ring) == nil;
285
    finish();
286
}