ax-task 0.6.10

ArceOS task management module
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
140
141
142
143
144
145
146

use super::*;

#[test]
fn held_lock_display_includes_class_addr_and_location() {
    let held = HeldLock {
        class_id: 3,
        kind: HeldLockKind::Spin,
        mode: HeldLockMode::Exclusive,
        sleep_forbidden: true,
        addr: 0x1234,
        caller: Location::caller(),
    };
    let rendered = held.to_string();
    assert!(rendered.contains("kind=spin"));
    assert!(rendered.contains("mode=exclusive"));
    assert!(rendered.contains("sleep_forbidden=true"));
    assert!(rendered.contains("class=3"));
    assert!(rendered.contains("addr=0x1234"));
    assert!(rendered.contains("acquired_at="));
}

#[cfg(target_pointer_width = "64")]
#[test]
fn subclass_support_does_not_increase_held_lock_state_size() {
    assert_eq!(core::mem::size_of::<HeldLock>(), 24);
    assert_eq!(core::mem::size_of::<HeldLockStack>(), 776);
    assert_eq!(core::mem::size_of::<HeldLockSnapshot>(), 776);
    assert_eq!(core::mem::size_of::<PreparedAcquire>(), 800);
}

#[test]
fn held_stack_display_marks_top_entry() {
    let caller = Location::caller();
    let mut snapshot = HeldLockSnapshot::new();
    snapshot.push(HeldLock {
        class_id: 2,
        kind: HeldLockKind::Spin,
        mode: HeldLockMode::Exclusive,
        sleep_forbidden: true,
        addr: 0x10,
        caller,
    });
    snapshot.push(HeldLock {
        class_id: 3,
        kind: HeldLockKind::Mutex,
        mode: HeldLockMode::Exclusive,
        sleep_forbidden: false,
        addr: 0x20,
        caller,
    });

    let rendered = HeldLockStackDisplay {
        snapshot: &snapshot,
        subclasses: &HeldLockSubclassSnapshot {
            values: [DEFAULT_LOCK_SUBCLASS; MAX_HELD_LOCK_SNAPSHOT],
        },
    }
    .to_string();
    assert!(rendered.contains("[0] held: kind=spin mode=exclusive sleep_forbidden=true class=2"));
    assert!(rendered.contains("[1] top: kind=mutex mode=exclusive sleep_forbidden=false class=3"));
}

#[test]
fn dynamic_lock_instances_do_not_consume_class_slots() {
    let locks: Vec<_> = (0..(MAX_LOCK_CLASSES + 128))
        .map(|_| LockdepMap::new_dynamic())
        .collect();

    for lock in &locks {
        let prepared = prepare_acquire_with_snapshot_checked(
            lock,
            "test lock",
            lock as *const _ as usize,
            Location::caller(),
            HeldLockSnapshot::new(),
        )
        .unwrap();
        assert_ne!(prepared.class_id(), 0);
    }
}

#[test]
fn subclass_tracks_same_base_class_nesting() {
    fn prepare_with_subclass(
        map: &LockdepMap,
        held_before: HeldLockSnapshot,
        subclass: LockSubclass,
    ) -> PreparedAcquire {
        prepare_acquire_with_snapshot_checked_nested(
            map,
            "test lock",
            map as *const _ as usize,
            Location::caller(),
            held_before,
            subclass,
        )
        .unwrap()
    }

    let parent = LockdepMap::new_dynamic();
    let child = LockdepMap::new_dynamic();
    let parent_acquire =
        prepare_with_subclass(&parent, HeldLockSnapshot::new(), DEFAULT_LOCK_SUBCLASS);
    let parent_class = parent_acquire.class_id();
    let mut parent_held = HeldLockSnapshot::new();
    parent_held.push(HeldLock {
        class_id: parent_class,
        kind: HeldLockKind::Spin,
        mode: HeldLockMode::Exclusive,
        sleep_forbidden: true,
        addr: &parent as *const _ as usize,
        caller: Location::caller(),
    });
    let child_acquire = prepare_with_subclass(&child, parent_held, 1);
    assert_eq!(class_subclass(parent_class), DEFAULT_LOCK_SUBCLASS);
    assert_eq!(class_subclass(child_acquire.class_id()), 1);

    let mut held_locks = HeldLockStack::new();
    finish_acquire_with_stack(
        parent_acquire,
        &parent as *const _ as usize,
        &mut held_locks,
    );
    finish_acquire_with_stack(child_acquire, &child as *const _ as usize, &mut held_locks);
    release_from_stack(&child as *const _ as usize, &mut held_locks);
    release_from_stack(&parent as *const _ as usize, &mut held_locks);

    let mut nested_held = HeldLockSnapshot::new();
    nested_held.push(HeldLock {
        class_id: child_acquire.class_id(),
        kind: HeldLockKind::Spin,
        mode: HeldLockMode::Exclusive,
        sleep_forbidden: true,
        addr: &child as *const _ as usize,
        caller: Location::caller(),
    });
    let reverse = prepare_acquire_with_snapshot_checked_nested(
        &parent,
        "test lock",
        &parent as *const _ as usize,
        Location::caller(),
        nested_held,
        DEFAULT_LOCK_SUBCLASS,
    );
    assert!(matches!(reverse, Err(LockdepCheckError::OrderInversion)));
}