test/loader/kernel/dispatchcheck.rad 7.1 KiB raw
1
//! Execute runtime-loaded native code after releasing its compiler workspace.
2
export mod inputs;
3
4
use std::mem;
5
use kernel::fixture;
6
use kernel::limits;
7
use kernel::state;
8
use kernel::abi;
9
use kernel::capability;
10
use kernel::pages;
11
use kernel::registry;
12
use kernel::loader;
13
use kernel::instances;
14
use kernel::domains;
15
use kernel::frames;
16
17
/// Capability storage for the loading domain.
18
unsafe static TABLE: capability::Table = undefined;
19
20
/// View a validated source Page as mapped bytes.
21
fn memory(address: u64) -> *mut u8;
22
23
/// Call a published entry with one instance's package-state table.
24
fn invoke(address: u64, table: u64) -> i64;
25
26
/// Count the frames that are free.
27
unsafe fn freeFrames() -> u32 {
28
    let mut count: u32 = 0;
29
    for i in 0 .. state::SHARED.pages.backings.pool.count {
30
        if frames::available(&state::SHARED.pages.backings.pool, i) {
31
            set count += 1;
32
        }
33
    }
34
    return count;
35
}
36
37
/// Copy a package into the source Page and load it, expecting the verifier to
38
/// reject it. The load leaves no frames, handles or loader ownership behind.
39
unsafe fn rejected(authority: abi::Handle, source: abi::Handle, bytes: &[u8]) {
40
    let cap = try! capability::lookup(&TABLE, source, abi::Kind::Page, abi::Rights(
41
        abi::WRITE
42
    ));
43
    let page = try! pages::get(&state::SHARED.pages, cap.object);
44
    let window = @sliceOf(memory(page.base), limits::FRAME_SIZE);
45
    let length = try! mem::copy(&mut window[..], bytes);
46
    let before = freeFrames();
47
    let mut failed = false;
48
    try loader::load(
49
        &mut state::SHARED.loader,
50
        &mut state::SHARED.pages,
51
        &mut state::SHARED.registry,
52
        &mut TABLE,
53
        loader::Request {
54
            authority, source, offset: 0, length: length as u64
55
        }
56
    ) catch error {
57
        assert error == abi::Error::VerifyFailed;
58
        set failed = true;
59
    };
60
    assert failed and state::SHARED.loader.owner == nil;
61
    assert freeFrames() == before;
62
}
63
64
/// Copy a package that grows slices in a heap into the source Page, load it, and execute its
65
/// entry, which returns 42 in the hosted run too. The heap region is zero-filled data of the
66
/// instance, so each instance grows its own slices.
67
unsafe fn grown(authority: abi::Handle, source: abi::Handle) {
68
    let cap = try! capability::lookup(&TABLE, source, abi::Kind::Page, abi::Rights(
69
        abi::WRITE
70
    ));
71
    let page = try! pages::get(&state::SHARED.pages, cap.object);
72
    let window = @sliceOf(memory(page.base), limits::FRAME_SIZE);
73
    let length = try! mem::copy(&mut window[..], &inputs::GROWN[..]);
74
    let handle = try! loader::load(
75
        &mut state::SHARED.loader,
76
        &mut state::SHARED.pages,
77
        &mut state::SHARED.registry,
78
        &mut TABLE,
79
        loader::Request {
80
            authority, source, offset: 0, length: length as u64
81
        }
82
    );
83
    let object = try! registry::image(&state::SHARED.registry, &TABLE, handle, abi::Rights(
84
        abi::EXECUTE
85
    ));
86
    let package = try! registry::get(&state::SHARED.registry, object);
87
    let entry = package.entry else panic "grown: loaded entry";
88
    let domain = try! domains::create(
89
        &mut state::SHARED.domains,
90
        &mut state::SHARED.pages.backings,
91
        &state::SHARED.registry,
92
        &mut TABLE,
93
        authority,
94
        handle
95
    );
96
    let domainEntry = try! capability::get(&TABLE, domain);
97
    let table = instances::address(&state::SHARED.domains.tables[domainEntry.object.index]);
98
    assert invoke(entry, table) == 42;
99
}
100
101
/// Load the hosted comparison package and execute its retained native
102
/// instructions.
103
export unsafe fn run() {
104
    let authority = fixture::bootstrap(&mut TABLE);
105
    let source = try! pages::allocate(
106
        &mut state::SHARED.pages, &mut TABLE, authority, 1
107
    );
108
    let cap = try! capability::lookup(&TABLE, source, abi::Kind::Page, abi::Rights(
109
        abi::READ
110
    ));
111
    let page = try! pages::get(&state::SHARED.pages, cap.object);
112
    let bytes = @sliceOf(memory(page.base), limits::FRAME_SIZE);
113
    let length = try! mem::copy(&mut bytes[..], &inputs::INPUT[..]);
114
    let handle = try! loader::load(
115
        &mut state::SHARED.loader,
116
        &mut state::SHARED.pages,
117
        &mut state::SHARED.registry,
118
        &mut TABLE,
119
        loader::Request {
120
            authority, source, offset: 0, length: length as u64
121
        }
122
    );
123
    assert state::SHARED.loader.owner == nil;
124
    let object = try! registry::image(&state::SHARED.registry, &TABLE, handle, abi::Rights(
125
        abi::EXECUTE
126
    ));
127
    let package = try! registry::get(&state::SHARED.registry, object);
128
    let entry = package.entry else panic "run: loaded entry";
129
    for i in 0 .. length {
130
        set bytes[i] = 0;
131
    }
132
    assert package.relocations.len > 0;
133
    let firstHandle = try! domains::create(
134
        &mut state::SHARED.domains,
135
        &mut state::SHARED.pages.backings,
136
        &state::SHARED.registry,
137
        &mut TABLE,
138
        authority,
139
        handle
140
    );
141
    let secondHandle = try! domains::create(
142
        &mut state::SHARED.domains,
143
        &mut state::SHARED.pages.backings,
144
        &state::SHARED.registry,
145
        &mut TABLE,
146
        authority,
147
        handle
148
    );
149
    let firstEntry = try! capability::get(&TABLE, firstHandle);
150
    let secondEntry = try! capability::get(&TABLE, secondHandle);
151
    let first = try! domains::get(&state::SHARED.domains, firstEntry.object);
152
    let second = try! domains::get(&state::SHARED.domains, secondEntry.object);
153
    assert first.state == domains::Lifecycle::Pending
154
        and second.state == domains::Lifecycle::Pending;
155
    assert state::SHARED.domains.contexts[first.initial.index].frame.pc
156
        == entry;
157
    assert state::SHARED.domains.contexts[second.initial.index].frame.pc
158
        == entry;
159
    assert first.memory.ring.mask == 255 and second.memory.ring.mask == 255;
160
    let tables = &state::SHARED.domains.tables;
161
    let firstTable = instances::address(&tables[firstEntry.object.index]);
162
    let secondTable = instances::address(&tables[secondEntry.object.index]);
163
    assert invoke(entry, firstTable) == 43;
164
    assert invoke(entry, firstTable) == 85;
165
    assert invoke(entry, secondTable) == 43;
166
    // A package that grows slices in a heap passes the verifier and runs.
167
    grown(authority, source);
168
    // Packages that break one rule of the verifier each: none is compiled or
169
    // published.
170
    rejected(authority, source, &inputs::HOSTILE_FORGED[..]);
171
    rejected(authority, source, &inputs::HOSTILE_OVERWRITE[..]);
172
    rejected(authority, source, &inputs::HOSTILE_LEAK[..]);
173
    rejected(authority, source, &inputs::HOSTILE_EXTERN[..]);
174
    rejected(authority, source, &inputs::HOSTILE_DEPENDENT[..]);
175
    rejected(authority, source, &inputs::HOSTILE_BUFFER[..]);
176
    rejected(authority, source, &inputs::HOSTILE_HEAPREAD[..]);
177
    rejected(authority, source, &inputs::HOSTILE_HEAPSLICE[..]);
178
    rejected(authority, source, &inputs::HOSTILE_HEAPFORGE[..]);
179
    rejected(authority, source, &inputs::HOSTILE_HEAPTYPED[..]);
180
    rejected(authority, source, &inputs::HOSTILE_HEAPRESET[..]);
181
    rejected(authority, source, &inputs::HOSTILE_MIXED[..]);
182
    rejected(authority, source, &inputs::HOSTILE_ZEROCAP[..]);
183
    rejected(authority, source, &inputs::HOSTILE_OMITCAP[..]);
184
}