rust/hrtimer: Various hrtimer + time additions
Subsystems (2)
Lyude Paul
reviewerv8 cover rust/hrtimer: Various hrtimer + time additions
This is a collection of various bindings that I added to hrtimer when I was originally getting it ready to be used in rvkms. I've mostly been waiting for Andreas's hrtimer series to go upstream before submitting these.
All of these are currently being used within rvkms for vblank emulation.
Previous versions:
Version 1: https://lkml.org/lkml/2025/4/2/1474
Version 2: https://lkml.org/lkml/2025/4/15/1750
Version 3 (only a revision of one patch): https://lkml.org/lkml/2025/4/15/1780
Version 4: https://lkml.org/lkml/2025/4/29/1715
Version 5: https://lkml.org/lkml/2025/6/13/1785
Version 6: https://lkml.org/lkml/2025/7/24/1390
Version 7: https://lkml.org/lkml/2025/8/13/1875
Usage example:
(keep in mind, I haven't rebased the example entirely - but the only
differences there is a few comments)
https://gitlab.freedesktop.org/lyudess/linux/-/tree/rvkms-slim/rust/kernel?ref_type=heads
Lyude Paul (7):
rust: hrtimer: Document the return value for HrTimerHandle::cancel()
rust: hrtimer: Add HrTimerInstant
rust: hrtimer: Add HrTimer::raw_forward() and forward()
rust: hrtimer: Add HrTimerCallbackContext and ::forward()
rust: hrtimer: Add forward_now() to HrTimer and HrTimerCallbackContext
rust: time: Add Instant::from_ktime()
rust: hrtimer: Add HrTimer::expires()
Patches changed since V7:
rust: hrtimer: Add HrTimer::expires()
(needs re-review!)
rust: time: Add Instant::from_ktime()
(needs re-review!)
Changelog:
rust: hrtimer: Document the return value for HrTimerHandle::cancel()
V4:
* Reword to "Returns true if the timer was running."
rust: hrtimer: Add HrTimerInstant
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.
V7:
* Split up Timer::forward() a bit, apply Andreas's SAFETY comment recommendations
rust: hrtimer: Add HrTimer::raw_forward() and forward()
rust: hrtimer: Add HrTimerCallbackContext and ::forward()
V2:
* Improve SAFETY comments for HrTimerCallbackContext uses (I forgot to mention that we're within RawHrTimerCallback::run()
* Split forward into forward() and raw_forward() since we're going to have two contexts that we can call forward() from now.
* Clarify contexts in which certain hrtimer methods can be called.
* Make sure that we use a mutable reference for forward() here - just in case :).
* Rename interval to duration
V3:
* Rename duration -back- to interval (now that I actually have read hrtimer_forward's source, interval does make more sense than duration considering the fact we return the number of overruns that occurred according to the given interval).
* Rewrite documentation a bit (re: Andreas)
V5:
* Fix unbounded T on HrTimerCallbackContext
V6:
* Move reference to HrTimerCallbackContext::forward() in HrTimer::forward() comments into this commit so rustdoc doesn't fail.
* Deduplicate documentation for HrTimerCallbackContext::forward()
* Add missing changelog note
rust: hrtimer: Add forward_now() to HrTimer and HrTimerCallbackContext
V2:
* Change from Ktime to Delta
* Make sure that forward_now() takes a mutable reference to the timer struct
* Reword this to point out that we're adding forward_now() to both callback context and mutable timer reference
* Rename interval to duration
V4:
* Fix rust documentation for HrTimerCallbackContext (forgot to update both forward_now() declarations)
* Use Pin<&mut Self> for context-less forward.
V6:
* Drop raw_cb_time(), use Instant::now() instead
* Split out expires() from this patch, at some point it seems I mistakenly combined it with this patch
V7:
* Remove leftover comment about raw_cb_time from patch description
rust: time: Add Instant::from_ktime()
V4:
* Turn from_nanos() into an unsafe function in order to ensure that we uphold the invariants of Instant
V5:
* Add debug_assert!() to from_nanos
V8:
* Change name of function from Instant::from_nanos() to Instant::from_ktime()
rust: hrtimer: Add HrTimer::expires()
V8:
* Fix bogus safety comment I noticed after Fujita's comments. In expires() we're not guaranteed to get a non-negative ktime_t because of ktime_t itself, we're guaranteed to get one because a negative expiration time for a timer doesn't make sense.
rust/kernel/time.rs | 22 ++++ rust/kernel/time/hrtimer.rs | 152 +++++++++++++++++++++++++++- rust/kernel/time/hrtimer/arc.rs | 9 +- rust/kernel/time/hrtimer/pin.rs | 9 +- rust/kernel/time/hrtimer/pin_mut.rs | 12 ++- rust/kernel/time/hrtimer/tbox.rs | 9 +- 6 files changed, 204 insertions(+), 9 deletions(-)
base-commit: c17b750b3ad9f45f2b6f7e6f7f4679844244f0b9
Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 1/7 rust: hrtimer: Document the return value for HrTimerHandle::cancel()
Just a drive-by fix I noticed: we don't actually document what the return value from cancel() does, so do that.
---
V4:
* Reword to "Returns true if the timer was running."
rust/kernel/time/hrtimer.rs | 2 ++ 1 file changed, 2 insertions(+)
rust/kernel/time/hrtimer.rs +2 -0
@@ -324,6 +324,8 @@ pub unsafe trait HrTimerHandle {/// Note that the timer might be started by a concurrent start operation. If /// so, the timer might not be in the **stopped** state when this function /// returns. +/// +/// Returns `true` if the timer was running. fn cancel (&mut self) ->bool ; }
Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 2/7 rust: hrtimer: Add HrTimerInstant
In reply to Lyude PaulSince we want to add HrTimer methods that can accept Instants, we will want to make sure that for each method we are using the correct Clocksource for the given HrTimer. This would get a bit overly-verbose, so add a simple HrTimerInstant type-alias to handle this for us.
--- rust/kernel/time/hrtimer.rs | 5 +++++ 1 file changed, 5 insertions(+)
rust/kernel/time/hrtimer.rs +5 -0
@@ -72,6 +72,11 @@use core::marker::PhantomData ;use pin_init::PinInit ; +/// A type-alias to refer to the [`Instant<C>`] for a given `T` from [`HrTimer<T>`]. +/// +/// Where `C` is the [`ClockSource`] of the [`HrTimer`]. +pub type HrTimerInstant <T > =Instant <<<T as HasHrTimer <T >>::TimerMode as HrTimerMode >::Clock >; +/// A timer backed by a C `struct hrtimer`. /// /// # Invariants
Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 3/7 rust: hrtimer: Add HrTimer::raw_forward() and forward()
In reply to Lyude PaulWithin 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.
---
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.
V7
* Split up Timer::forward() a bit, apply Andreas's SAFETY comment recommendations
rust/kernel/time/hrtimer.rs | 40 +++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)
rust/kernel/time/hrtimer.rs +40 -0
@@ -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` +let this =unsafe { self.get_unchecked_mut () }; + +// SAFETY: By existence of `Pin<&mut Self>`, the pointer passed to `raw_forward` points to a +// valid `Self` that we have exclusive access to. +unsafe {Self ::raw_forward (this, now, interval) } + } }/// Implemented by pointer types that point to structs that contain a [`HrTimer`].
Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 4/7 rust: hrtimer: Add HrTimerCallbackContext and ::forward()
In reply to Lyude PaulWith Linux's hrtimer API, there's a number of methods that can only be called in two situations:
* When we have exclusive access to the hrtimer and it is not currently active
* When we're within the context of an hrtimer callback context
This commit handles the second situation and implements hrtimer_forward() support in the context of a timer callback. We do this by introducing a HrTimerCallbackContext type which is provided to users during the RawHrTimerCallback::run() callback, and then add a forward() function to the type.
---
V2:
* Improve SAFETY comments for HrTimerCallbackContext uses (I forgot to mention that we're within RawHrTimerCallback::run()
* Split forward into forward() and raw_forward() since we're going to have two contexts that we can call forward() from now.
* Clarify contexts in which certain hrtimer methods can be called.
* Make sure that we use a mutable reference for forward() here - just in case :).
* Rename interval to duration
V3:
* Rename duration -back- to interval (now that I actually have read hrtimer_forward's source, interval does make more sense than duration considering the fact we return the number of overruns that occurred according to the given interval).
* Rewrite documentation a bit (re: Andreas)
V5:
* Fix unbounded T on HrTimerCallbackContext
V6:
* Move reference to HrTimerCallbackContext::forward() in HrTimer::forward() comments into this commit so rustdoc doesn't fail.
* Deduplicate documentation for HrTimerCallbackContext::forward()
* Add missing changelog note
rust/kernel/time/hrtimer.rs | 63 +++++++++++++++++++++++++++-- rust/kernel/time/hrtimer/arc.rs | 9 ++++- rust/kernel/time/hrtimer/pin.rs | 9 ++++- rust/kernel/time/hrtimer/pin_mut.rs | 12 ++++-- rust/kernel/time/hrtimer/tbox.rs | 9 ++++- 5 files changed, 93 insertions(+), 9 deletions(-)
rust/kernel/time/hrtimer.rs +60 -3
@@ -69,7 +69,7 @@use super ::{ClockSource ,Delta ,Instant };use crate ::{prelude::*, types::Opaque }; -use core::marker::PhantomData ; +use core::{marker::PhantomData , ptr::NonNull };use pin_init::PinInit ;/// A type-alias to refer to the [`Instant<C>`] for a given `T` from [`HrTimer<T>`].
@@ -196,6 +196,10 @@ unsafe fn raw_forward(self_ptr: *mut Self, now: HrTimerInstant<T>, interval: Del/// expires after `now` and then returns the number of times the timer was forwarded by /// `interval`. /// +/// This function is mainly useful for timer types which can provide exclusive access to the +/// timer when the timer is not running. For forwarding the timer from within the timer callback +/// context, see [`HrTimerCallbackContext::forward()`]. +/// /// 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
@@ -345,9 +349,13 @@ pub trait HrTimerCallback {type Pointer <'a>:RawHrTimerCallback ;/// Called by the timer logic when the timer fires. -fn run (this: <Self ::Pointer <'_>as RawHrTimerCallback >::CallbackTarget <'_>) ->HrTimerRestart +fn run ( + this: <Self ::Pointer <'_>as RawHrTimerCallback >::CallbackTarget <'_>, + ctx:HrTimerCallbackContext <'_,Self >, + ) ->HrTimerRestart where -Self :Sized ; +Self :Sized , +Self :HasHrTimer <Self >; }/// A handle representing a potentially running timer.
@@ -632,6 +640,55 @@ impl<C: ClockSource> HrTimerMode for RelativePinnedHardMode<C> {type Expires =Delta ; } +/// Privileged smart-pointer for a [`HrTimer`] callback context. +/// +/// Many [`HrTimer`] methods can only be called in two situations: +/// +/// * When the caller has exclusive access to the `HrTimer` and the `HrTimer` is guaranteed not to +/// be running. +/// * From within the context of an `HrTimer`'s callback method. +/// +/// This type provides access to said methods from within a timer callback context. +/// +/// # Invariants +/// +/// * The existence of this type means the caller is currently within the callback for an +/// [`HrTimer`]. +/// * `self.0` always points to a live instance of [`HrTimer<T>`]. +pub struct HrTimerCallbackContext <'a,T :HasHrTimer <T >>(NonNull <HrTimer <T >>,PhantomData <&'a ()>); + +impl <'a,T :HasHrTimer <T >>HrTimerCallbackContext <'a,T > { +/// Create a new [`HrTimerCallbackContext`]. +/// +/// # Safety +/// +/// This function relies on the caller being within the context of a timer callback, so it must +/// not be used anywhere except for within implementations of [`RawHrTimerCallback::run`]. The +/// caller promises that `timer` points to a valid initialized instance of +/// [`bindings::hrtimer`]. +/// +/// The returned `Self` must not outlive the function context of [`RawHrTimerCallback::run`] +/// where this function is called. +pub (crate )unsafe fn from_raw (timer: *mut HrTimer <T >) ->Self { +// SAFETY: The caller guarantees `timer` is a valid pointer to an initialized +// `bindings::hrtimer` +// INVARIANT: Our safety contract ensures that we're within the context of a timer callback +// and that `timer` points to a live instance of `HrTimer<T>`. +Self (unsafe {NonNull ::new_unchecked (timer) },PhantomData ) + } + +/// Conditionally forward the timer. +/// +/// This function is identical to [`HrTimer::forward()`] except that it may only be used from +/// within the context of a [`HrTimer`] callback. +pub fn forward (&mut self, now:HrTimerInstant <T >, interval:Delta ) ->u64 { +// SAFETY: +// - We are guaranteed to be within the context of a timer callback by our type invariants +// - By our type invariants, `self.0` always points to a valid `HrTimer<T>` +unsafe {HrTimer ::<T >::raw_forward (self.0 .as_ptr (), now, interval) } + } +} +/// Use to implement the [`HasHrTimer<T>`] trait. /// /// See [`module`] documentation for an example.
rust/kernel/time/hrtimer/arc.rs +8 -1
@@ -3,6 +3,7 @@use super ::HasHrTimer ;use super ::HrTimer ;use super ::HrTimerCallback ; +use super ::HrTimerCallbackContext ;use super ::HrTimerHandle ;use super ::HrTimerMode ;use super ::HrTimerPointer ;
@@ -99,6 +100,12 @@ impl<T> RawHrTimerCallback for Arc<T>// allocation from other `Arc` clones. let receiver =unsafe {ArcBorrow ::from_raw (data_ptr) }; -T ::run (receiver).into_c () +// SAFETY: +// - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so +// it is a valid pointer to a `HrTimer<T>` embedded in a `T`. +// - We are within `RawHrTimerCallback::run` +let context =unsafe {HrTimerCallbackContext ::from_raw (timer_ptr) }; + +T ::run (receiver, context).into_c () } }
rust/kernel/time/hrtimer/pin.rs +8 -1
@@ -3,6 +3,7 @@use super ::HasHrTimer ;use super ::HrTimer ;use super ::HrTimerCallback ; +use super ::HrTimerCallbackContext ;use super ::HrTimerHandle ;use super ::HrTimerMode ;use super ::RawHrTimerCallback ;
@@ -103,6 +104,12 @@ impl<'a, T> RawHrTimerCallback for Pin<&'a T>// here. let receiver_pin =unsafe {Pin ::new_unchecked (receiver_ref) }; -T ::run (receiver_pin).into_c () +// SAFETY: +// - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so +// it is a valid pointer to a `HrTimer<T>` embedded in a `T`. +// - We are within `RawHrTimerCallback::run` +let context =unsafe {HrTimerCallbackContext ::from_raw (timer_ptr) }; + +T ::run (receiver_pin, context).into_c () } }
rust/kernel/time/hrtimer/pin_mut.rs +9 -3
@@ -1,8 +1,8 @@// SPDX-License-Identifier: GPL-2.0 use super ::{ -HasHrTimer ,HrTimer ,HrTimerCallback ,HrTimerHandle ,HrTimerMode ,RawHrTimerCallback , -UnsafeHrTimerPointer , +HasHrTimer ,HrTimer ,HrTimerCallback ,HrTimerCallbackContext ,HrTimerHandle ,HrTimerMode , +RawHrTimerCallback ,UnsafeHrTimerPointer , };use core::{marker::PhantomData , pin::Pin , ptr::NonNull };
@@ -107,6 +107,12 @@ impl<'a, T> RawHrTimerCallback for Pin<&'a mut T>// here. let receiver_pin =unsafe {Pin ::new_unchecked (receiver_ref) }; -T ::run (receiver_pin).into_c () +// SAFETY: +// - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so +// it is a valid pointer to a `HrTimer<T>` embedded in a `T`. +// - We are within `RawHrTimerCallback::run` +let context =unsafe {HrTimerCallbackContext ::from_raw (timer_ptr) }; + +T ::run (receiver_pin, context).into_c () } }
rust/kernel/time/hrtimer/tbox.rs +8 -1
@@ -3,6 +3,7 @@use super ::HasHrTimer ;use super ::HrTimer ;use super ::HrTimerCallback ; +use super ::HrTimerCallbackContext ;use super ::HrTimerHandle ;use super ::HrTimerMode ;use super ::HrTimerPointer ;
@@ -119,6 +120,12 @@ impl<T, A> RawHrTimerCallback for Pin<Box<T, A>>// `data_ptr` exist. let data_mut_ref =unsafe {Pin ::new_unchecked (&mut *data_ptr) }; -T ::run (data_mut_ref).into_c () +// SAFETY: +// - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so +// it is a valid pointer to a `HrTimer<T>` embedded in a `T`. +// - We are within `RawHrTimerCallback::run` +let context =unsafe {HrTimerCallbackContext ::from_raw (timer_ptr) }; + +T ::run (data_mut_ref, context).into_c () } }
Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 5/7 rust: hrtimer: Add forward_now() to HrTimer and HrTimerCallbackContext
In reply to Lyude Paul---
V2:
* Change from Ktime to Delta
* Make sure that forward_now() takes a mutable reference to the timer struct
* Reword this to point out that we're adding forward_now() to both callback context and mutable timer reference
* Rename interval to duration
V4:
* Fix rust documentation for HrTimerCallbackContext (forgot to update both forward_now() declarations)
* Use Pin<&mut Self> for context-less forward.
V6:
* Drop raw_cb_time(), use Instant::now() instead
* Split out expires() from this patch, at some point it seems I mistakenly combined it with this patch
V7:
* Remove leftover comment about raw_cb_time from patch description
rust/kernel/time/hrtimer.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
rust/kernel/time/hrtimer.rs +19 -0
@@ -212,6 +212,17 @@ pub fn forward(self: Pin<&mut Self>, now: HrTimerInstant<T>, interval: Delta) ->// valid `Self` that we have exclusive access to. unsafe {Self ::raw_forward (this, now, interval) } } + +/// Conditionally forward the timer. +/// +/// This is a variant of [`forward()`](Self::forward) that uses an interval after the current +/// time of the base clock for the [`HrTimer`]. +pub fn forward_now (self:Pin <&mut Self >, interval:Delta ) ->u64 +where +T :HasHrTimer <T >, + { + self.forward (HrTimerInstant ::<T >::now (), interval) + } }/// Implemented by pointer types that point to structs that contain a [`HrTimer`].
@@ -687,6 +698,14 @@ pub fn forward(&mut self, now: HrTimerInstant<T>, interval: Delta) -> u64 {// - By our type invariants, `self.0` always points to a valid `HrTimer<T>` unsafe {HrTimer ::<T >::raw_forward (self.0 .as_ptr (), now, interval) } } + +/// Conditionally forward the timer. +/// +/// This is a variant of [`HrTimerCallbackContext::forward()`] that uses an interval after the +/// current time of the base clock for the [`HrTimer`]. +pub fn forward_now (&mut self, duration:Delta ) ->u64 { + self.forward (HrTimerInstant ::<T >::now (), duration) + } }/// Use to implement the [`HasHrTimer<T>`] trait.
Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 6/7 rust: time: Add Instant::from_ktime()
In reply to Lyude PaulFor implementing Rust bindings which can return a point in time.
---
V4:
* Turn from_nanos() into an unsafe function in order to ensure that we uphold the invariants of Instant
V5:
* Add debug_assert!() to from_nanos
V8:
* Change name of function from Instant::from_nanos() to Instant::from_ktime()
rust/kernel/time.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
rust/kernel/time.rs +23 -0
@@ -200,6 +200,29 @@ pub fn elapsed(&self) -> Delta {pub (crate )fn as_nanos (&self) ->i64 { self.inner } + +/// Create an [`Instant`] from a `ktime_t` without checking if it is non-negative. +/// +/// # Panics +/// +/// On debug builds, this function will panic if `nanos` is not in the range from 0 to +/// `KTIME_MAX`. +/// +/// # Safety +/// +/// The caller promises that `nanos` is in the range from 0 to `KTIME_MAX`. +#[expect(unused)] +#[inline] +pub (crate )unsafe fn from_ktime (ktime: bindings::ktime_t ) ->Self { +debug_assert! (ktime >=0 ); + +// INVARIANT: Our safety contract ensures that `nanos` is in the range from 0 to +// `KTIME_MAX`. +Self { + inner: ktime, + _c:PhantomData , + } + } }impl <C :ClockSource > core::ops::Sub for Instant <C > {
Signature · 1 line
2.50.0
FUJITA Tomonori
reviewerRe: [PATCH v8 6/7] rust: time: Add Instant::from_ktime()
Quoted 14 lines · On Tue, 19 Aug 2025 16:05:57 -0400 Lyude Paul <[email protected]> wrote:
For implementing Rust bindings which can return a point in time.
Signed-off-by Lyude Paul <[email protected]>---
V4:
* Turnfrom_nanos()into an unsafe function in order to ensure that we uphold the invariants of Instant
V5:
* Add debug_assert!() tofrom_nanos
V8:
* Change name of function fromInstant::from_nanos()toInstant::from_ktime()
Quoted 2 lines
rust/kernel/time.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
Thanks!
Quoted 9 lines
rust/kernel/time.rs +1
-0@@ -200,6 +200,29 @@ pub fn elapsed(&self) -> Delta {pub (crate )fn as_nanos (&self) ->i64 { self.inner } +
rust/kernel/time.rs pub fn elapsed(&self) -> Delta { · line 213
Quoted 10 lines
rust/kernel/time.rs +10
-0+/// Create an [`Instant`] from a `ktime_t` without checking if it is non-negative. +/// +/// # Panics +/// +/// On debug builds, this function will panic if `nanos` is not in the range from 0 to +/// `KTIME_MAX`. +/// +/// # Safety +/// +/// The caller promises that `nanos` is in the range from 0 to `KTIME_MAX`.
The comment looks outdated. 'ktime'?
rust/kernel/time.rs pub fn elapsed(&self) -> Delta { · line 219
Quoted 6 lines
rust/kernel/time.rs +6
-0+#[expect(unused)] +#[inline] +pub (crate )unsafe fn from_ktime (ktime: bindings::ktime_t ) ->Self { +debug_assert! (ktime >=0 ); + +// INVARIANT: Our safety contract ensures that `nanos` is in the range from 0 to
Ditto.
Quoted 13 lines
rust/kernel/time.rs +6
-0+// `KTIME_MAX`. +Self { + inner: ktime, + _c:PhantomData , + } + } }impl <C :ClockSource > core::ops::Sub for Instant <C > {Signature · 1 line
2.50.0
Lyude Paul
reviewerPATCH v8 7/7 rust: hrtimer: Add HrTimer::expires()
In reply to Lyude PaulAdd a simple callback for retrieving the current expiry time for an HrTimer. In rvkms, we use the HrTimer expiry value in order to calculate the approximate vblank timestamp during each emulated vblank interrupt.
---
V8:
* Fix bogus safety comment I noticed after Fujita's comments. In expires() we're not guaranteed to get a non-negative ktime_t because of ktime_t itself, we're guaranteed to get one because a negative expiration time for a timer doesn't make sense.
rust/kernel/time.rs | 1 - rust/kernel/time/hrtimer.rs | 23 +++++++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-)
rust/kernel/time.rs +0 -1
@@ -211,7 +211,6 @@ pub(crate) fn as_nanos(&self) -> i64 {/// # Safety /// /// The caller promises that `nanos` is in the range from 0 to `KTIME_MAX`. -#[expect(unused)] #[inline] pub (crate )unsafe fn from_ktime (ktime: bindings::ktime_t ) ->Self {debug_assert! (ktime >=0 );
rust/kernel/time/hrtimer.rs +23 -0
@@ -223,6 +223,29 @@ pub fn forward_now(self: Pin<&mut Self>, interval: Delta) -> u64 { self.forward (HrTimerInstant ::<T >::now (), interval) } + +/// Return the time expiry for this [`HrTimer`]. +/// +/// This value should only be used as a snapshot, as the actual expiry time could change after +/// this function is called. +pub fn expires (&self) ->HrTimerInstant <T > +where +T :HasHrTimer <T >, + { +// SAFETY: `self` is an immutable reference and thus always points to a valid `HrTimer`. +let c_timer_ptr =unsafe {HrTimer ::raw_get (self) }; + +// SAFETY: +// - Timers cannot have negative ktime_t values as their expiration time. +// - There's no actual locking here, a racy read is fine and expected +unsafe { +Instant ::from_ktime ( +// This `read_volatile` is intended to correspond to a READ_ONCE call. +// FIXME(read_once): Replace with `read_once` when available on the Rust side. + core::ptr::read_volatile (&raw const ((*c_timer_ptr).node.expires)), + ) + } + } }/// Implemented by pointer types that point to structs that contain a [`HrTimer`].
Signature · 1 line
2.50.0