std/sys/pal/unix/sync/
condvar.rs

1use super::Mutex;
2use crate::cell::UnsafeCell;
3use crate::pin::Pin;
4#[cfg(not(target_os = "nto"))]
5use crate::sys::pal::time::TIMESPEC_MAX;
6#[cfg(target_os = "nto")]
7use crate::sys::pal::time::TIMESPEC_MAX_CAPPED;
8use crate::sys::pal::time::Timespec;
9use crate::time::Duration;
10
11pub struct Condvar {
12    inner: UnsafeCell<libc::pthread_cond_t>,
13}
14
15impl Condvar {
16    pub fn new() -> Condvar {
17        Condvar { inner: UnsafeCell::new(libc::PTHREAD_COND_INITIALIZER) }
18    }
19
20    #[inline]
21    fn raw(&self) -> *mut libc::pthread_cond_t {
22        self.inner.get()
23    }
24
25    /// # Safety
26    /// `init` must have been called on this instance.
27    #[inline]
28    pub unsafe fn notify_one(self: Pin<&Self>) {
29        let r = unsafe { libc::pthread_cond_signal(self.raw()) };
30        debug_assert_eq!(r, 0);
31    }
32
33    /// # Safety
34    /// `init` must have been called on this instance.
35    #[inline]
36    pub unsafe fn notify_all(self: Pin<&Self>) {
37        let r = unsafe { libc::pthread_cond_broadcast(self.raw()) };
38        debug_assert_eq!(r, 0);
39    }
40
41    /// # Safety
42    /// * `init` must have been called on this instance.
43    /// * `mutex` must be locked by the current thread.
44    /// * This condition variable may only be used with the same mutex.
45    #[inline]
46    pub unsafe fn wait(self: Pin<&Self>, mutex: Pin<&Mutex>) {
47        let r = unsafe { libc::pthread_cond_wait(self.raw(), mutex.raw()) };
48        debug_assert_eq!(r, 0);
49    }
50
51    /// # Safety
52    /// * `init` must have been called on this instance.
53    /// * `mutex` must be locked by the current thread.
54    /// * This condition variable may only be used with the same mutex.
55    pub unsafe fn wait_timeout(&self, mutex: Pin<&Mutex>, dur: Duration) -> bool {
56        let mutex = mutex.raw();
57
58        // OSX implementation of `pthread_cond_timedwait` is buggy
59        // with super long durations. When duration is greater than
60        // 0x100_0000_0000_0000 seconds, `pthread_cond_timedwait`
61        // in macOS Sierra returns error 316.
62        //
63        // This program demonstrates the issue:
64        // https://gist.github.com/stepancheg/198db4623a20aad2ad7cddb8fda4a63c
65        //
66        // To work around this issue, the timeout is clamped to 1000 years.
67        #[cfg(target_vendor = "apple")]
68        let dur = Duration::min(dur, Duration::from_secs(1000 * 365 * 86400));
69
70        let timeout = Timespec::now(Self::CLOCK).checked_add_duration(&dur);
71
72        #[cfg(not(target_os = "nto"))]
73        let timeout = timeout.and_then(|t| t.to_timespec()).unwrap_or(TIMESPEC_MAX);
74
75        #[cfg(target_os = "nto")]
76        let timeout = timeout.and_then(|t| t.to_timespec_capped()).unwrap_or(TIMESPEC_MAX_CAPPED);
77
78        let r = unsafe { libc::pthread_cond_timedwait(self.raw(), mutex, &timeout) };
79        assert!(r == libc::ETIMEDOUT || r == 0);
80        r == 0
81    }
82}
83
84#[cfg(not(any(
85    target_os = "android",
86    target_vendor = "apple",
87    target_os = "espidf",
88    target_os = "horizon",
89    target_os = "l4re",
90    target_os = "redox",
91    target_os = "teeos",
92)))]
93impl Condvar {
94    pub const PRECISE_TIMEOUT: bool = true;
95    const CLOCK: libc::clockid_t = libc::CLOCK_MONOTONIC;
96
97    /// # Safety
98    /// May only be called once per instance of `Self`.
99    pub unsafe fn init(self: Pin<&mut Self>) {
100        use crate::mem::MaybeUninit;
101
102        struct AttrGuard<'a>(pub &'a mut MaybeUninit<libc::pthread_condattr_t>);
103        impl Drop for AttrGuard<'_> {
104            fn drop(&mut self) {
105                unsafe {
106                    let result = libc::pthread_condattr_destroy(self.0.as_mut_ptr());
107                    assert_eq!(result, 0);
108                }
109            }
110        }
111
112        unsafe {
113            let mut attr = MaybeUninit::<libc::pthread_condattr_t>::uninit();
114            let r = libc::pthread_condattr_init(attr.as_mut_ptr());
115            assert_eq!(r, 0);
116            let attr = AttrGuard(&mut attr);
117            let r = libc::pthread_condattr_setclock(attr.0.as_mut_ptr(), Self::CLOCK);
118            assert_eq!(r, 0);
119            let r = libc::pthread_cond_init(self.raw(), attr.0.as_ptr());
120            assert_eq!(r, 0);
121        }
122    }
123}
124
125// `pthread_condattr_setclock` is unfortunately not supported on these platforms.
126#[cfg(any(
127    target_os = "android",
128    target_vendor = "apple",
129    target_os = "espidf",
130    target_os = "horizon",
131    target_os = "l4re",
132    target_os = "redox",
133    target_os = "teeos",
134))]
135impl Condvar {
136    pub const PRECISE_TIMEOUT: bool = false;
137    const CLOCK: libc::clockid_t = libc::CLOCK_REALTIME;
138
139    /// # Safety
140    /// May only be called once per instance of `Self`.
141    pub unsafe fn init(self: Pin<&mut Self>) {
142        if cfg!(any(target_os = "espidf", target_os = "horizon", target_os = "teeos")) {
143            // NOTE: ESP-IDF's PTHREAD_COND_INITIALIZER support is not released yet
144            // So on that platform, init() should always be called.
145            //
146            // Similar story for the 3DS (horizon) and for TEEOS.
147            let r = unsafe { libc::pthread_cond_init(self.raw(), crate::ptr::null()) };
148            assert_eq!(r, 0);
149        }
150    }
151}
152
153impl !Unpin for Condvar {}
154
155unsafe impl Sync for Condvar {}
156unsafe impl Send for Condvar {}
157
158impl Drop for Condvar {
159    #[inline]
160    fn drop(&mut self) {
161        let r = unsafe { libc::pthread_cond_destroy(self.raw()) };
162        if cfg!(target_os = "dragonfly") {
163            // On DragonFly pthread_cond_destroy() returns EINVAL if called on
164            // a condvar that was just initialized with
165            // libc::PTHREAD_COND_INITIALIZER. Once it is used or
166            // pthread_cond_init() is called, this behaviour no longer occurs.
167            debug_assert!(r == 0 || r == libc::EINVAL);
168        } else {
169            debug_assert_eq!(r, 0);
170        }
171    }
172}