starry-kernel 0.10.2

A Linux-compatible OS kernel built on ArceOS unikernel
Documentation 
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

use super::{accounting::CpuTimeSnapshot, *};

pub struct RttimeWatchdog {
    reset_generation: u64,
    soft_limit_us: u64,
    next_signal_us: u64,
}

impl RttimeWatchdog {
    pub(crate) const fn new() -> Self {
        Self {
            reset_generation: 0,
            soft_limit_us: u64::MAX,
            next_signal_us: u64::MAX,
        }
    }

    pub(crate) fn check_limit_at(
        &mut self,
        accounting: &CpuTimeAccounting,
        runtime_ns: u64,
        soft_limit_us: u64,
        hard_limit_us: u64,
    ) -> RttimeLimitAction {
        self.check_snapshot(
            accounting.snapshot(runtime_ns),
            soft_limit_us,
            hard_limit_us,
        )
    }

    fn check_snapshot(
        &mut self,
        snapshot: CpuTimeSnapshot,
        soft_limit_us: u64,
        hard_limit_us: u64,
    ) -> RttimeLimitAction {
        if !snapshot.realtime_policy {
            self.reset(snapshot.realtime_reset_generation, soft_limit_us);
            return RttimeLimitAction::None;
        }
        self.check(
            snapshot.realtime_continuous_ns / 1_000,
            snapshot.realtime_reset_generation,
            soft_limit_us,
            hard_limit_us,
        )
    }

    fn check(
        &mut self,
        runtime_us: u64,
        reset_generation: u64,
        soft_limit_us: u64,
        hard_limit_us: u64,
    ) -> RttimeLimitAction {
        if hard_limit_us != u64::MAX && runtime_us >= hard_limit_us {
            return RttimeLimitAction::Hard;
        }
        if soft_limit_us == u64::MAX {
            self.reset(reset_generation, soft_limit_us);
            return RttimeLimitAction::None;
        }
        if self.reset_generation != reset_generation || self.soft_limit_us != soft_limit_us {
            self.reset(reset_generation, soft_limit_us);
        }
        if runtime_us >= self.next_signal_us {
            self.next_signal_us = self.next_signal_us.saturating_add(1_000_000);
            RttimeLimitAction::Soft
        } else {
            RttimeLimitAction::None
        }
    }

    fn reset(&mut self, reset_generation: u64, soft_limit_us: u64) {
        self.reset_generation = reset_generation;
        self.soft_limit_us = soft_limit_us;
        self.next_signal_us = soft_limit_us;
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RttimeLimitAction {
    None,
    Soft,
    Hard,
}

include!("rttime/tests.rs");