ax-task 0.7.0

OS-independent IRQ-safe SMP task scheduling core
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

use core::panic::Location;

use crate::sync::{
    lockdep as common,
    lockdep::{HeldLockSnapshot, LockSubclass, LockdepMapView, PreparedAcquire},
    mutex::RawMutex,
};

fn current_held_locks() -> HeldLockSnapshot {
    common::current_task_held_lock_snapshot()
}

pub(crate) struct LockdepAcquire {
    addr: usize,
    prepared: PreparedAcquire,
    inner: common::Lockdep,
}

pub(in crate::sync) struct LockdepAcquireRequest<'lock> {
    pub map: LockdepMapView<'lock>,
    pub addr: usize,
    pub subclass: LockSubclass,
    pub is_try: bool,
    pub caller: &'static Location<'static>,
}

impl LockdepAcquire {
    #[inline(always)]
    #[track_caller]
    pub(crate) fn prepare_nested(lock: &RawMutex, is_try: bool, subclass: LockSubclass) -> Self {
        let addr = lock as *const _ as *const () as usize;
        Self::prepare_view(LockdepAcquireRequest {
            map: lock.lockdep.view(),
            addr,
            subclass,
            is_try,
            caller: Location::caller(),
        })
    }

    pub(in crate::sync) fn prepare_view(request: LockdepAcquireRequest<'_>) -> Self {
        let prepared = common::prepare_acquire_with_snapshot_view_nested_with_sleep(
            request.map,
            "mutex",
            request.addr,
            request.caller,
            current_held_locks(),
            request.subclass,
            false,
        );
        let inner = common::Lockdep::prepare("mutex", request.addr, request.is_try, None);
        Self {
            addr: request.addr,
            prepared,
            inner,
        }
    }

    #[inline(always)]
    pub(crate) fn finish(self, acquired: bool) {
        self.inner.finish(acquired);
        if acquired {
            common::finish_acquire_task(self.prepared, self.addr);
        }
    }
}

#[inline(always)]
pub(crate) fn release(lock: &RawMutex) {
    let addr = lock as *const _ as *const () as usize;
    release_external(addr);
}

#[inline(always)]
pub(in crate::sync) fn release_external(addr: usize) {
    common::release_task(addr);
    common::Lockdep::release("mutex", addr, None);
}