ax-fs-ng 0.7.0

ArceOS filesystem module
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

use alloc::{boxed::Box, string::String};
use core::{
    sync::atomic::{AtomicBool, Ordering},
    time::Duration,
};

use ax_kspin::SpinRwLock as RwLock;

pub trait BlockTaskOps: Send + Sync {
    fn current_task_id(&self) -> Option<u64>;
    fn task_yield(&self);
    fn task_wait(&self);
    fn task_wait_timeout(&self, dur: Duration) -> bool {
        let _ = dur;
        self.task_yield();
        true
    }
    fn task_wait_until(&self, condition: &dyn Fn() -> bool) {
        while !condition() {
            self.task_wait();
        }
    }
    fn wake_task(&self, task_id: u64);
    fn notify_waiters(&self) {}
    fn notify_drain(&self) {
        self.notify_waiters();
    }
    fn notify_drain_from_irq(&self) {
        self.notify_drain();
    }
    fn wait_for_drain_notification(&self) {
        self.task_wait();
    }
    fn spawn(&self, _name: String, _f: Box<dyn FnOnce() + Send + 'static>) {}
}

static TASK_OPS: RwLock<Option<&'static dyn BlockTaskOps>> = RwLock::new(None);
static TASK_READY: AtomicBool = AtomicBool::new(false);

pub fn set_task_ops(ops: &'static dyn BlockTaskOps) {
    *TASK_OPS.write() = Some(ops);
    TASK_READY.store(true, Ordering::Release);
}

fn task_ops() -> Option<&'static dyn BlockTaskOps> {
    TASK_OPS.read().as_ref().copied()
}

pub fn current_task_id() -> Option<u64> {
    task_ops().and_then(|ops| ops.current_task_id())
}

pub fn task_yield() {
    if let Some(ops) = task_ops() {
        ops.task_yield();
    }
}

pub fn task_wait() {
    if let Some(ops) = task_ops() {
        ops.task_wait();
    }
}

pub fn task_wait_timeout(dur: Duration) -> bool {
    task_ops().is_some_and(|ops| ops.task_wait_timeout(dur))
}

pub fn task_wait_until(condition: impl Fn() -> bool) {
    if let Some(ops) = task_ops() {
        ops.task_wait_until(&condition);
    } else {
        while !condition() {
            core::hint::spin_loop();
        }
    }
}

pub fn wake_task(task_id: u64) {
    if let Some(ops) = task_ops() {
        ops.wake_task(task_id);
    }
}

pub fn notify_waiters() {
    if let Some(ops) = task_ops() {
        ops.notify_waiters();
    }
}

pub fn notify_drain() {
    if let Some(ops) = task_ops() {
        ops.notify_drain();
    }
}

pub fn notify_drain_from_irq() {
    if let Some(ops) = task_ops() {
        ops.notify_drain_from_irq();
    }
}

pub fn wait_for_drain_notification() {
    if let Some(ops) = task_ops() {
        ops.wait_for_drain_notification();
    } else {
        core::hint::spin_loop();
    }
}

pub fn spawn_task(name: String, f: Box<dyn FnOnce() + Send + 'static>) {
    if let Some(ops) = task_ops() {
        ops.spawn(name, f);
    }
}

pub fn has_task_ops() -> bool {
    TASK_READY.load(Ordering::Acquire)
}