starry-kernel 0.10.0

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Process job-control state and parent-report delivery.

use alloc::sync::Arc;

use axpoll::IoEvents;
use axpoll_set::PollSet;
use starry_signal::Signo;

use super::{ProcessData, TidNumber};
use crate::sync::IrqMutex;

/// A pending job-control status change for `waitpid`.
#[derive(Clone, Copy)]
pub enum JobStatus {
    Stopped(Signo),
    Continued,
}

/// Live stop state and one-shot parent report.
///
/// The two fields intentionally remain independent: a stopped process may
/// already have had its parent report consumed.
#[derive(Default)]
struct JobControl {
    stopped: Option<Signo>,
    status: Option<JobStatus>,
    continue_generation: u64,
    /// The thread physically parked by the process-directed stop.
    waiter_tid: Option<TidNumber>,
}

pub(super) struct ProcessJobControl {
    state: IrqMutex<JobControl>,
    continue_event: Arc<PollSet>,
}

impl ProcessJobControl {
    pub(super) fn new() -> Self {
        Self {
            state: IrqMutex::new(JobControl::default()),
            continue_event: Arc::default(),
        }
    }
}

impl ProcessData {
    pub fn is_job_stopped(&self) -> bool {
        self.job_control.state.lock().stopped.is_some()
    }

    pub fn set_job_stopped(
        &self,
        signo: Signo,
        continue_gen_snapshot: u64,
        waiter_tid: TidNumber,
    ) -> bool {
        let mut state = self.job_control.state.lock();
        if state.continue_generation != continue_gen_snapshot {
            return false;
        }
        state.stopped = Some(signo);
        state.status = Some(JobStatus::Stopped(signo));
        state.waiter_tid = Some(waiter_tid);
        true
    }

    /// Returns whether `tid` is the thread physically parked for this stop.
    pub fn is_job_stop_waiter(&self, tid: TidNumber) -> bool {
        let state = self.job_control.state.lock();
        state.stopped.is_some() && state.waiter_tid == Some(tid)
    }

    pub fn continue_generation(&self) -> u64 {
        self.job_control.state.lock().continue_generation
    }

    pub fn set_job_continued(&self) -> bool {
        let mut state = self.job_control.state.lock();
        state.continue_generation = state.continue_generation.wrapping_add(1);
        let was_stopped = state.stopped.take().is_some();
        state.waiter_tid = None;
        if was_stopped {
            state.status = Some(JobStatus::Continued);
            drop(state);
            // Continue state is visible before parked threads are woken.
            unsafe { self.job_control.continue_event.wake(IoEvents::IN) };
        }
        was_stopped
    }

    pub fn clear_job_stop_for_kill(&self) {
        let mut state = self.job_control.state.lock();
        let was_stopped = state.stopped.take().is_some();
        state.waiter_tid = None;
        drop(state);
        if was_stopped {
            // Kill observes cleared stop state before the wake.
            unsafe { self.job_control.continue_event.wake(IoEvents::IN) };
        }
    }

    /// Wakes the parked stop waiter so it can publish a pending ptrace event.
    ///
    /// This does not change the job-control state. Only continue or kill may
    /// release the stop.
    pub fn wake_job_stop_waiter(&self) {
        unsafe { self.job_control.continue_event.wake(IoEvents::IN) };
    }

    pub fn cont_event(&self) -> Arc<PollSet> {
        self.job_control.continue_event.clone()
    }

    pub fn peek_job_status_if(
        &self,
        want_stopped: bool,
        want_continued: bool,
    ) -> Option<JobStatus> {
        let state = self.job_control.state.lock();
        match state.status {
            Some(status @ JobStatus::Stopped(_)) if want_stopped => Some(status),
            Some(status @ JobStatus::Continued) if want_continued => Some(status),
            _ => None,
        }
    }

    pub fn take_job_status_if(
        &self,
        want_stopped: bool,
        want_continued: bool,
    ) -> Option<JobStatus> {
        let mut state = self.job_control.state.lock();
        match state.status {
            Some(JobStatus::Stopped(_)) if want_stopped => state.status.take(),
            Some(JobStatus::Continued) if want_continued => state.status.take(),
            _ => None,
        }
    }
}