test/smp/kernel/invariants.rad 3.6 KiB 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
}