[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-ID: <87h5yj6kny.fsf@kernel.org>
Date: Thu, 07 Aug 2025 20:39:29 +0200
From: Andreas Hindborg <a.hindborg@...nel.org>
To: Lyude Paul <lyude@...hat.com>, rust-for-linux@...r.kernel.org, Thomas
Gleixner <tglx@...utronix.de>, Boqun Feng <boqun.feng@...il.com>,
linux-kernel@...r.kernel.org, FUJITA Tomonori <fujita.tomonori@...il.com>
Cc: Frederic Weisbecker <frederic@...nel.org>, Anna-Maria Behnsen
<anna-maria@...utronix.de>, John Stultz <jstultz@...gle.com>, Stephen
Boyd <sboyd@...nel.org>, Miguel Ojeda <ojeda@...nel.org>, Alex Gaynor
<alex.gaynor@...il.com>, Gary Guo <gary@...yguo.net>, Björn Roy Baron
<bjorn3_gh@...tonmail.com>, Benno Lossin <lossin@...nel.org>, Alice Ryhl
<aliceryhl@...gle.com>, Trevor Gross <tmgross@...ch.edu>, Danilo Krummrich
<dakr@...nel.org>
Subject: Re: [PATCH v6 3/7] rust: hrtimer: Add HrTimer::raw_forward() and
forward()
"Lyude Paul" <lyude@...hat.com> writes:
> Within the hrtimer API there are quite a number of functions that can only
> be safely called from one of two contexts:
>
> * When we have exclusive access to the hrtimer and the timer is not active.
> * When we're within the hrtimer's callback context as it is being executed.
>
> This commit adds bindings for hrtimer_forward() for the first such context,
> along with HrTimer::raw_forward() for later use in implementing the
> hrtimer_forward() in the latter context.
>
> Signed-off-by: Lyude Paul <lyude@...hat.com>
>
> ---
> V4:
> * Fix the safety contract for raw_forward()
> * Require Pin<&mut Self>, not &mut self
> * Drop incorrect UniquePin example
> * Rewrite documentation a bit (re: Andreas)
> V6:
> * Remove the reference to HrTimerCallbackContext::forward() until this
> function gets added.
>
> Signed-off-by: Lyude Paul <lyude@...hat.com>
> ---
> rust/kernel/time/hrtimer.rs | 40 +++++++++++++++++++++++++++++++++++++
> 1 file changed, 40 insertions(+)
>
> diff --git a/rust/kernel/time/hrtimer.rs b/rust/kernel/time/hrtimer.rs
> index be1bad4aacaad..5ccdd1b0b8021 100644
> --- a/rust/kernel/time/hrtimer.rs
> +++ b/rust/kernel/time/hrtimer.rs
> @@ -168,6 +168,46 @@ pub(crate) unsafe fn raw_cancel(this: *const Self) -> bool {
> // handled on the C side.
> unsafe { bindings::hrtimer_cancel(c_timer_ptr) != 0 }
> }
> +
> + /// Forward the timer expiry for a given timer pointer.
> + ///
> + /// # Safety
> + ///
> + /// - `self_ptr` must point to a valid `Self`.
> + /// - The caller must either have exclusive access to the data pointed at by `self_ptr`, or be
> + /// within the context of the timer callback.
> + #[inline]
> + unsafe fn raw_forward(self_ptr: *mut Self, now: HrTimerInstant<T>, interval: Delta) -> u64
> + where
> + T: HasHrTimer<T>,
> + {
> + // SAFETY:
> + // * The C API requirements for this function are fulfilled by our safety contract.
> + // * `self_ptr` is guaranteed to point to a valid `Self` via our safety contract
> + unsafe {
> + bindings::hrtimer_forward(Self::raw_get(self_ptr), now.as_nanos(), interval.as_nanos())
> + }
> + }
> +
> + /// Conditionally forward the timer.
> + ///
> + /// If the timer expires after `now`, this function does nothing and returns 0. If the timer
> + /// expired at or before `now`, this function forwards the timer by `interval` until the timer
> + /// expires after `now` and then returns the number of times the timer was forwarded by
> + /// `interval`.
> + ///
> + /// Returns the number of overruns that occurred as a result of the timer expiry change.
> + pub fn forward(self: Pin<&mut Self>, now: HrTimerInstant<T>, interval: Delta) -> u64
> + where
> + T: HasHrTimer<T>,
> + {
> + // SAFETY:
> + // - `raw_forward` does not move `self`.
> + // - Self is a mutable reference and thus always points to a valid `HrTimer`
> + // - The only way that we could hold a mutable reference to `HrTimer<T>` is if we have
> + // exclusive access to it - fulfilling the requirements of the C API.
C API requirements are not relevant for this call. Maybe you can replace
the last two lines by:
By existence of `Pin<&mut Self>`, the pointer passed to `raw_forward`
points to a valid `Self` that we have exclusive access to.
It is slightly obscure because we coerce `self.get_unchecked_mut() ->
&mut Self` to `*mut Self` in one go. Perhaps split it up:
let self_ptr: *mut Self = self.get_unchecked_mut();
// SAFETY: ...
unsafe { Self::raw_forward(self_ptr, now, interval) }
Best regards,
Andreas Hindborg
Powered by blists - more mailing lists