[PATCH v3 4/5] rust: sync: condvar: use task::schedule_timeout()

From: Danilo Krummrich

Date: Mon Nov 16 2026 - 19:16:07 EST


Convert CondVar::wait_internal() from calling
bindings::schedule_timeout() directly to using the safe
task::schedule_timeout() wrapper. This removes the unsafe call from
CondVar.

Signed-off-by: Danilo Krummrich <dakr@xxxxxxxxxx>
---
rust/kernel/sync/condvar.rs | 42 ++++++++++++++++++-------------------
1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/rust/kernel/sync/condvar.rs b/rust/kernel/sync/condvar.rs
index 2deeaf2038e4..dae07dc140c5 100644
--- a/rust/kernel/sync/condvar.rs
+++ b/rust/kernel/sync/condvar.rs
@@ -16,7 +16,7 @@
prelude::*,
str::CStr,
task::{
- MAX_SCHEDULE_TIMEOUT,
+ self,
TASK_FREEZABLE,
TASK_INTERRUPTIBLE,
TASK_UNINTERRUPTIBLE, //
@@ -107,11 +107,10 @@ fn wait_internal<T: ?Sized, B: Backend>(
&self,
wait_state: c_int,
guard: &mut Guard<'_, T, B>,
- timeout_in_jiffies: c_long,
- ) -> c_long {
+ timeout: Delta<Jiffy>,
+ ) -> Delta<Jiffy> {
self.wq.wait_once_exclusive(wait_state, || {
- // SAFETY: Switches to another thread. The timeout can be any number.
- guard.do_unlocked(|| unsafe { bindings::schedule_timeout(timeout_in_jiffies) })
+ guard.do_unlocked(|| task::schedule_timeout(timeout))
})
}

@@ -122,7 +121,11 @@ fn wait_internal<T: ?Sized, B: Backend>(
/// [`CondVar::notify_one`] or [`CondVar::notify_all`]. Note that it may also wake up
/// spuriously.
pub fn wait<T: ?Sized, B: Backend>(&self, guard: &mut Guard<'_, T, B>) {
- self.wait_internal(TASK_UNINTERRUPTIBLE, guard, MAX_SCHEDULE_TIMEOUT);
+ self.wait_internal(
+ TASK_UNINTERRUPTIBLE,
+ guard,
+ Delta::from_jiffies(task::MAX_SCHEDULE_TIMEOUT),
+ );
}

/// Releases the lock and waits for a notification in interruptible mode.
@@ -133,7 +136,11 @@ pub fn wait<T: ?Sized, B: Backend>(&self, guard: &mut Guard<'_, T, B>) {
/// Returns whether there is a signal pending.
#[must_use = "wait_interruptible returns if a signal is pending, so the caller must check the return value"]
pub fn wait_interruptible<T: ?Sized, B: Backend>(&self, guard: &mut Guard<'_, T, B>) -> bool {
- self.wait_internal(TASK_INTERRUPTIBLE, guard, MAX_SCHEDULE_TIMEOUT);
+ self.wait_internal(
+ TASK_INTERRUPTIBLE,
+ guard,
+ Delta::from_jiffies(task::MAX_SCHEDULE_TIMEOUT),
+ );
crate::current!().signal_pending()
}

@@ -151,7 +158,7 @@ pub fn wait_interruptible_freezable<T: ?Sized, B: Backend>(
self.wait_internal(
TASK_INTERRUPTIBLE | TASK_FREEZABLE,
guard,
- MAX_SCHEDULE_TIMEOUT,
+ Delta::from_jiffies(task::MAX_SCHEDULE_TIMEOUT),
);
crate::current!().signal_pending()
}
@@ -169,21 +176,12 @@ pub fn wait_interruptible_timeout<T: ?Sized, B: Backend>(
guard: &mut Guard<'_, T, B>,
timeout: Delta<Jiffy>,
) -> CondVarTimeoutResult {
- let jiffies = timeout.as_jiffies();
- let res = self.wait_internal(
- TASK_INTERRUPTIBLE,
- guard,
- jiffies.clamp(0, MAX_SCHEDULE_TIMEOUT),
- );
+ let remaining = self.wait_internal(TASK_INTERRUPTIBLE, guard, timeout);

- match (res, crate::current!().signal_pending()) {
- (remainder, true) => CondVarTimeoutResult::Signal {
- remainder: Delta::from_jiffies(remainder),
- },
- (0, false) => CondVarTimeoutResult::Timeout,
- (remainder, false) => CondVarTimeoutResult::Woken {
- remainder: Delta::from_jiffies(remainder),
- },
+ match (remaining, current!().signal_pending()) {
+ (remainder, true) => CondVarTimeoutResult::Signal { remainder },
+ (Delta::ZERO, false) => CondVarTimeoutResult::Timeout,
+ (remainder, false) => CondVarTimeoutResult::Woken { remainder },
}
}

--
2.56.1