ax-sync 0.5.14

ArceOS synchronization primitives
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

use core::panic::Location;

use ax_kspin::lockdep::{self as common, HeldLockSnapshot, PreparedAcquire};
pub(crate) use ax_kspin::lockdep::{LockSubclass, LockdepMap};

use crate::mutex::RawMutex;

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

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

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;
        let prepared = common::prepare_acquire_with_snapshot_nested(
            &lock.lockdep,
            "mutex",
            addr,
            Location::caller(),
            current_held_locks(),
            subclass,
        );
        let inner = ax_lockdep::Lockdep::prepare("mutex", addr, is_try, None);
        Self {
            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;
    common::release_task(addr);
    ax_lockdep::Lockdep::release("mutex", addr, None);
}