.githooks/
compiler/
kernel/
lib/
scripts/
seed/
sublime/
test/
boot/
bootstrap/
compiler/
cycles/
dispatch/
format/
host/
integration/
kernel/
loader/
manifests/
mmio/
native/
packages/
runtime/
scheduling/
shared/
slots/
smp/
kernel/
dispatchcheck.rad
39.6 KiB
invariants.rad
3.6 KiB
cases.rad
1.6 KiB
machine.ras
1.5 KiB
spin.rad
3.9 KiB
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/smp/kernel/invariants.rad
raw
| 1 | //! Final ownership and interval checks over published kernel objects. |
| 2 | use kernel::state; |
| 3 | use kernel::abi; |
| 4 | use kernel::boot; |
| 5 | use kernel::slots; |
| 6 | use kernel::capability; |
| 7 | use kernel::domains; |
| 8 | use kernel::budgets; |
| 9 | use kernel::interrupts; |
| 10 | use kernel::sync; |
| 11 | |
| 12 | /// Select authoritative capability storage, including the fixture's boot owner. |
| 13 | /// The bootstrap table and domain memory must outlive the metadata transaction. |
| 14 | unsafe fn table(owner: abi::Ref, bootstrap: &capability::Table) -> *unsafe capability::Table { |
| 15 | if owner == bootstrap.owner { |
| 16 | return bootstrap as *unsafe capability::Table; |
| 17 | } |
| 18 | let domain = try! domains::get(&state::SHARED.domains, owner); |
| 19 | assert domain.state <> domains::Lifecycle::Dead; |
| 20 | assert domain.memory.table.owner == owner; |
| 21 | return &domain.memory.table; |
| 22 | } |
| 23 | |
| 24 | /// Check live references, exclusive execution ownership, and disjoint CPU windows. |
| 25 | /// Each budget or IRQ check uses a separate bounded metadata transaction. |
| 26 | export unsafe fn check(bootstrap: &capability::Table) { |
| 27 | let guard = sync::enter(); |
| 28 | let mut occupied: u32 = 0; |
| 29 | for i in 0 .. state::SHARED.domains.contextSlots.len { |
| 30 | if state::SHARED.domains.contextSlots[i].state <> slots::State::Live { |
| 31 | continue; |
| 32 | } |
| 33 | let context = state::SHARED.domains.contexts[i]; |
| 34 | let owner = try! domains::get(&state::SHARED.domains, context.owner); |
| 35 | assert owner.state <> domains::Lifecycle::Dead; |
| 36 | if let hart = context.hart { |
| 37 | assert hart < 8 and (boot::PLATFORM.harts & (1 << hart)) <> 0; |
| 38 | assert (occupied & (1 << hart)) == 0; |
| 39 | set occupied |= 1 << hart; |
| 40 | } |
| 41 | } |
| 42 | sync::leave(guard); |
| 43 | for i in 0 .. state::SHARED.budgets.slots.len { |
| 44 | let guard = sync::enter(); |
| 45 | if state::SHARED.budgets.slots[i].state == slots::State::Live { |
| 46 | let object = abi::Ref { |
| 47 | index: i, generation: state::SHARED.budgets.slots[i].generation |
| 48 | }; |
| 49 | let window = try! budgets::get(&state::SHARED.budgets, object); |
| 50 | assert window.start < window.end and window.hart < 8; |
| 51 | assert (boot::PLATFORM.harts & (1 << window.hart)) <> 0; |
| 52 | let owner = table(window.owner, bootstrap); |
| 53 | let entry = try! capability::get(&*owner, window.handle); |
| 54 | assert entry.kind == abi::Kind::Budget and entry.object == object; |
| 55 | if let context = window.context { |
| 56 | let bound = try! domains::context(&state::SHARED.domains, window.owner, context); |
| 57 | assert bound.owner == window.owner; |
| 58 | } |
| 59 | for j in i + 1 .. state::SHARED.budgets.slots.len { |
| 60 | if state::SHARED.budgets.slots[j].state <> slots::State::Live { |
| 61 | continue; |
| 62 | } |
| 63 | let other = state::SHARED.budgets.windows[j]; |
| 64 | if other.hart == window.hart { |
| 65 | assert window.end <= other.start or other.end <= window.start; |
| 66 | } |
| 67 | } |
| 68 | } |
| 69 | sync::leave(guard); |
| 70 | } |
| 71 | for i in 0 .. state::SHARED.interrupts.count { |
| 72 | let guard = sync::enter(); |
| 73 | if state::SHARED.interrupts.slots[i].state == slots::State::Live { |
| 74 | let object = abi::Ref { |
| 75 | index: i, generation: state::SHARED.interrupts.slots[i].generation |
| 76 | }; |
| 77 | let irq = try! interrupts::get(&state::SHARED.interrupts, object); |
| 78 | let owner = table(irq.owner, bootstrap); |
| 79 | let entry = try! capability::get(&*owner, irq.handle); |
| 80 | assert entry.kind == abi::Kind::Interrupt and entry.object == object; |
| 81 | } |
| 82 | sync::leave(guard); |
| 83 | } |
| 84 | } |