.githooks/
compiler/
kernel/
lib/
scripts/
seed/
sublime/
test/
boot/
bootstrap/
compiler/
cycles/
dispatch/
format/
host/
integration/
kernel/
loader/
kernel/
dispatchcheck.rad
7.1 KiB
grown.rad
1.2 KiB
hostile.rad
15.0 KiB
loaded.rad
586 B
machine.ras
731 B
manifests/
mmio/
native/
packages/
runtime/
scheduling/
shared/
slots/
smp/
std/
sync/
termination/
tests/
trap/
verify/
Makefile
9.2 KiB
kernel.rad
776 B
runner.rad
11.6 KiB
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
test/loader/kernel/dispatchcheck.rad
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 | } |