sbi-testing 0.0.1

Provide a set of test cases for supervisors to verify functions of the supervisor executation environment
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Timer programmer extension test suite

use crate::thread::Thread;
use riscv::register::scause::{self, Trap};

/// Timer programmer extension test cases
#[derive(Clone, Debug)]
pub enum Case {
    /// Can't procceed test for Timer extension does not exist
    NotExist,
    /// Test begin
    Begin,
    /// Test process for time interval overhead between two reads
    Interval {
        /// The time counter value for the first read
        begin: u64,
        /// The time counter value for the second read
        end: u64,
    },
    /// Test failed for can't read `time` register
    ReadFailed,
    /// Test failed for time counter has decreased during period of two reads
    TimeDecreased {
        /// The time counter value for the first read
        a: u64,
        /// The time counter value for the second read
        b: u64,
    },
    /// Test process for timer has been set
    SetTimer,
    /// Test failed for unexpected trap during timer test
    UnexpectedTrap(Trap),
    /// All test cases on timer extension has passed
    Pass,
}

/// Test timer extension.
pub fn test(delay: u64, mut f: impl FnMut(Case)) {
    use riscv::register::{scause::Interrupt, sie, time};

    if sbi::probe_extension(sbi::Timer).is_unavailable() {
        f(Case::NotExist);
        return;
    }
    f(Case::Begin);
    let begin: u64;
    let end: u64;
    let mut ok = 0xffusize;
    unsafe {
        core::arch::asm!(
            "   la   {stvec}, 1f
                csrw stvec,   {stvec}
                csrr {begin}, time
                csrr {end},   time
                mv   {ok},    zero
            .align 2
            1:
            ",
            stvec = out(reg) _,
            begin = out(reg) begin,
            end   = out(reg) end,
            ok    = inlateout(reg) ok,
        );
    }
    if ok != 0 {
        f(Case::ReadFailed);
        return;
    }
    if begin >= end {
        f(Case::TimeDecreased { a: begin, b: end });
        return;
    }
    f(Case::Interval { begin, end });

    let mut stack = [0usize; 32];
    let mut thread = Thread::new(riscv::asm::wfi as _);
    *thread.sp_mut() = stack.as_mut_ptr_range().end as _;

    sbi::set_timer(time::read64() + delay);
    unsafe {
        sie::set_stimer();
        thread.execute();
    }
    match scause::read().cause() {
        Trap::Interrupt(Interrupt::SupervisorTimer) => {
            sbi::set_timer(u64::MAX);
            f(Case::SetTimer);
            f(Case::Pass);
        }
        trap => {
            f(Case::UnexpectedTrap(trap));
        }
    }
}