SEDSnet 4.0.0

A memory safe, no_std-capable networking stack with routing, discovery, reliability, and Rust/C/Python bindings.
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Lightweight mutex abstraction for `Router`
//!
//! This module provides a small wrapper type, [`RouterMutex`], which
//! abstracts over `std::sync::Mutex` (when the `std` feature is enabled)
//! and host-provided lock hooks (`telemetry_lock` / `telemetry_unlock`) in
//! `no_std` builds.
//!
//! The goal is to provide a uniform API where:
//! - In `std` builds, a poisoned mutex will **panic** with
//!   `"RouterMutex poisoned"` rather than forcing callers to handle
//!   `PoisonError` everywhere.
//! - In `no_std` builds, locking delegates to platform hooks.
//!
//! Typical usage:
//!
//! ```text
//! let m = RouterMutex::new(router);
//! {
//!     let mut r = m.lock();
//!     // use `r`
//! }
//! ```

use core::sync::atomic::{AtomicBool, Ordering};

#[derive(Debug)]
pub struct ReentryGate {
    busy: AtomicBool,
}

pub struct ReentryGuard<'a> {
    busy: &'a AtomicBool,
}

impl ReentryGate {
    #[inline]
    pub const fn new() -> Self {
        Self {
            busy: AtomicBool::new(false),
        }
    }

    #[inline]
    pub fn try_enter(&self) -> Option<ReentryGuard<'_>> {
        self.busy
            .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
            .ok()
            .map(|_| ReentryGuard { busy: &self.busy })
    }

    #[inline]
    pub fn is_active(&self) -> bool {
        self.busy.load(Ordering::Acquire)
    }
}

impl Drop for ReentryGuard<'_> {
    #[inline]
    fn drop(&mut self) {
        self.busy.store(false, Ordering::Release);
    }
}

// ============================================================================
//  std implementation
// ============================================================================

#[cfg(feature = "std")]
#[derive(Debug)]
pub struct RouterMutex<T>(std::sync::Mutex<T>);

impl<T> Clone for RouterMutex<T>
where
    T: Clone,
{
    fn clone(&self) -> Self {
        RouterMutex::new(self.lock().clone())
    }
}
#[cfg(feature = "std")]
impl<T> RouterMutex<T> {
    /// Create a new `RouterMutex` wrapping the given value.
    #[inline]
    pub fn new(v: T) -> Self {
        Self(std::sync::Mutex::new(v))
    }

    /// Acquire the lock, panicking if the mutex has been poisoned.
    ///
    /// This is a convenience for router usage where poisoning is treated
    /// as a fatal error. Internally calls `.lock().expect("RouterMutex poisoned")`.
    #[inline]
    pub fn lock(&self) -> std::sync::MutexGuard<'_, T> {
        self.0.lock().expect("RouterMutex poisoned")
    }
}

// ============================================================================
//  no_std implementation via telemetry_lock / telemetry_unlock
// ============================================================================

#[cfg(not(feature = "std"))]
unsafe extern "C" {
    fn telemetry_lock();
    fn telemetry_unlock();
}

#[cfg(not(feature = "std"))]
pub struct RouterMutex<T>(core::cell::UnsafeCell<T>);

#[cfg(not(feature = "std"))]
unsafe impl<T: Send> Send for RouterMutex<T> {}

#[cfg(not(feature = "std"))]
unsafe impl<T: Send> Sync for RouterMutex<T> {}

#[cfg(not(feature = "std"))]
pub struct RouterMutexGuard<'a, T> {
    m: &'a RouterMutex<T>,
}

#[cfg(not(feature = "std"))]
impl<T> core::ops::Deref for RouterMutexGuard<'_, T> {
    type Target = T;

    #[inline]
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.m.0.get() }
    }
}

#[cfg(not(feature = "std"))]
impl<T> core::ops::DerefMut for RouterMutexGuard<'_, T> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *self.m.0.get() }
    }
}

#[cfg(not(feature = "std"))]
impl<T> Drop for RouterMutexGuard<'_, T> {
    #[inline]
    fn drop(&mut self) {
        unsafe { telemetry_unlock() }
    }
}

#[cfg(not(feature = "std"))]
impl<T> RouterMutex<T> {
    /// Create a new `RouterMutex` wrapping the given value.
    #[inline]
    pub fn new(v: T) -> Self {
        Self(core::cell::UnsafeCell::new(v))
    }

    /// Acquire the lock.
    ///
    /// In `no_std` builds this uses host-provided `telemetry_lock` /
    /// `telemetry_unlock` hooks.
    #[inline]
    pub fn lock(&self) -> RouterMutexGuard<'_, T> {
        unsafe { telemetry_lock() }
        RouterMutexGuard { m: self }
    }
}