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

use super::*;

/// Applies userspace disable intent and fences any live owner-CPU generation.
pub(crate) fn disable_counter(ptc: &Arc<PerTaskCounter>) -> crate::StarryResult<()> {
    ptc.enabled.store(false, Ordering::Release);
    // Never retain the non-sleeping run-state lock across an owner-CPU worker
    // rendezvous. See `stop_requested_on_owner` for the temporary-lifetime trap.
    let action = ptc.run_state.lock().begin_disable();
    let result = match action {
        PmuCloseAction::AlreadyClosed | PmuCloseAction::Complete => {
            ptc.finish_enabled_context(now_ns());
            Ok(())
        }
        PmuCloseAction::Stop(lease) => cpu_worker::stop_task_counter(Arc::clone(ptc), lease),
    };
    if result.is_ok() {
        ptc.publish_rdpmc_inactive();
    }
    result
}

/// Resets a task-bound count between two complete scheduling generations.
pub(crate) fn reset_counter(ptc: &Arc<PerTaskCounter>) -> crate::StarryResult<()> {
    // A one-shot owner snapshot is insufficient: the target can migrate before
    // the fixed worker runs and start a new slice on another CPU. Quiescing the
    // exact generation first gives RESET one Linux-style context boundary.
    let was_enabled = ptc.enabled.swap(false, Ordering::AcqRel);
    if let Err(error) = disable_counter(ptc) {
        if was_enabled {
            ptc.set_enabled();
        }
        return Err(error);
    }
    ptc.accumulated.store(0, Ordering::Release);
    ptc.sample_read_floor.store(0, Ordering::Release);
    ptc.counting_extender.lock().reset();
    ptc.publish_rdpmc_inactive();
    if was_enabled && !ptc.resources_released() {
        ptc.set_enabled();
        ptc.synchronize_context()?;
    }
    Ok(())
}