kernel/time/
hrtimer.rs

1// SPDX-License-Identifier: GPL-2.0
2
3//! Intrusive high resolution timers.
4//!
5//! Allows running timer callbacks without doing allocations at the time of
6//! starting the timer. For now, only one timer per type is allowed.
7//!
8//! # Vocabulary
9//!
10//! States:
11//!
12//! - Stopped: initialized but not started, or cancelled, or not restarted.
13//! - Started: initialized and started or restarted.
14//! - Running: executing the callback.
15//!
16//! Operations:
17//!
18//! * Start
19//! * Cancel
20//! * Restart
21//!
22//! Events:
23//!
24//! * Expire
25//!
26//! ## State Diagram
27//!
28//! ```text
29//!                                                   Return NoRestart
30//!                       +---------------------------------------------------------------------+
31//!                       |                                                                     |
32//!                       |                                                                     |
33//!                       |                                                                     |
34//!                       |                                         Return Restart              |
35//!                       |                                      +------------------------+     |
36//!                       |                                      |                        |     |
37//!                       |                                      |                        |     |
38//!                       v                                      v                        |     |
39//!           +-----------------+      Start      +------------------+           +--------+-----+--+
40//!           |                 +---------------->|                  |           |                 |
41//! Init      |                 |                 |                  |  Expire   |                 |
42//! --------->|    Stopped      |                 |      Started     +---------->|     Running     |
43//!           |                 |     Cancel      |                  |           |                 |
44//!           |                 |<----------------+                  |           |                 |
45//!           +-----------------+                 +---------------+--+           +-----------------+
46//!                                                     ^         |
47//!                                                     |         |
48//!                                                     +---------+
49//!                                                      Restart
50//! ```
51//!
52//!
53//! A timer is initialized in the **stopped** state. A stopped timer can be
54//! **started** by the `start` operation, with an **expiry** time. After the
55//! `start` operation, the timer is in the **started** state. When the timer
56//! **expires**, the timer enters the **running** state and the handler is
57//! executed. After the handler has returned, the timer may enter the
58//! **started* or **stopped** state, depending on the return value of the
59//! handler. A timer in the **started** or **running** state may be **canceled**
60//! by the `cancel` operation. A timer that is cancelled enters the **stopped**
61//! state.
62//!
63//! A `cancel` or `restart` operation on a timer in the **running** state takes
64//! effect after the handler has returned and the timer has transitioned
65//! out of the **running** state.
66//!
67//! A `restart` operation on a timer in the **stopped** state is equivalent to a
68//! `start` operation.
69
70use super::{ClockSource, Delta, Instant};
71use crate::{prelude::*, types::Opaque};
72use core::marker::PhantomData;
73use pin_init::PinInit;
74
75/// A timer backed by a C `struct hrtimer`.
76///
77/// # Invariants
78///
79/// * `self.timer` is initialized by `bindings::hrtimer_setup`.
80#[pin_data]
81#[repr(C)]
82pub struct HrTimer<T> {
83    #[pin]
84    timer: Opaque<bindings::hrtimer>,
85    _t: PhantomData<T>,
86}
87
88// SAFETY: Ownership of an `HrTimer` can be moved to other threads and
89// used/dropped from there.
90unsafe impl<T> Send for HrTimer<T> {}
91
92// SAFETY: Timer operations are locked on the C side, so it is safe to operate
93// on a timer from multiple threads.
94unsafe impl<T> Sync for HrTimer<T> {}
95
96impl<T> HrTimer<T> {
97    /// Return an initializer for a new timer instance.
98    pub fn new() -> impl PinInit<Self>
99    where
100        T: HrTimerCallback,
101        T: HasHrTimer<T>,
102    {
103        pin_init!(Self {
104            // INVARIANT: We initialize `timer` with `hrtimer_setup` below.
105            timer <- Opaque::ffi_init(move |place: *mut bindings::hrtimer| {
106                // SAFETY: By design of `pin_init!`, `place` is a pointer to a
107                // live allocation. hrtimer_setup will initialize `place` and
108                // does not require `place` to be initialized prior to the call.
109                unsafe {
110                    bindings::hrtimer_setup(
111                        place,
112                        Some(T::Pointer::run),
113                        <<T as HasHrTimer<T>>::TimerMode as HrTimerMode>::Clock::ID,
114                        <T as HasHrTimer<T>>::TimerMode::C_MODE,
115                    );
116                }
117            }),
118            _t: PhantomData,
119        })
120    }
121
122    /// Get a pointer to the contained `bindings::hrtimer`.
123    ///
124    /// This function is useful to get access to the value without creating
125    /// intermediate references.
126    ///
127    /// # Safety
128    ///
129    /// `this` must point to a live allocation of at least the size of `Self`.
130    unsafe fn raw_get(this: *const Self) -> *mut bindings::hrtimer {
131        // SAFETY: The field projection to `timer` does not go out of bounds,
132        // because the caller of this function promises that `this` points to an
133        // allocation of at least the size of `Self`.
134        unsafe { Opaque::cast_into(core::ptr::addr_of!((*this).timer)) }
135    }
136
137    /// Cancel an initialized and potentially running timer.
138    ///
139    /// If the timer handler is running, this function will block until the
140    /// handler returns.
141    ///
142    /// Note that the timer might be started by a concurrent start operation. If
143    /// so, the timer might not be in the **stopped** state when this function
144    /// returns.
145    ///
146    /// Users of the `HrTimer` API would not usually call this method directly.
147    /// Instead they would use the safe [`HrTimerHandle::cancel`] on the handle
148    /// returned when the timer was started.
149    ///
150    /// This function is useful to get access to the value without creating
151    /// intermediate references.
152    ///
153    /// # Safety
154    ///
155    /// `this` must point to a valid `Self`.
156    pub(crate) unsafe fn raw_cancel(this: *const Self) -> bool {
157        // SAFETY: `this` points to an allocation of at least `HrTimer` size.
158        let c_timer_ptr = unsafe { HrTimer::raw_get(this) };
159
160        // If the handler is running, this will wait for the handler to return
161        // before returning.
162        // SAFETY: `c_timer_ptr` is initialized and valid. Synchronization is
163        // handled on the C side.
164        unsafe { bindings::hrtimer_cancel(c_timer_ptr) != 0 }
165    }
166}
167
168/// Implemented by pointer types that point to structs that contain a [`HrTimer`].
169///
170/// `Self` must be [`Sync`] because it is passed to timer callbacks in another
171/// thread of execution (hard or soft interrupt context).
172///
173/// Starting a timer returns a [`HrTimerHandle`] that can be used to manipulate
174/// the timer. Note that it is OK to call the start function repeatedly, and
175/// that more than one [`HrTimerHandle`] associated with a [`HrTimerPointer`] may
176/// exist. A timer can be manipulated through any of the handles, and a handle
177/// may represent a cancelled timer.
178pub trait HrTimerPointer: Sync + Sized {
179    /// The operational mode associated with this timer.
180    ///
181    /// This defines how the expiration value is interpreted.
182    type TimerMode: HrTimerMode;
183
184    /// A handle representing a started or restarted timer.
185    ///
186    /// If the timer is running or if the timer callback is executing when the
187    /// handle is dropped, the drop method of [`HrTimerHandle`] should not return
188    /// until the timer is stopped and the callback has completed.
189    ///
190    /// Note: When implementing this trait, consider that it is not unsafe to
191    /// leak the handle.
192    type TimerHandle: HrTimerHandle;
193
194    /// Start the timer with expiry after `expires` time units. If the timer was
195    /// already running, it is restarted with the new expiry time.
196    fn start(self, expires: <Self::TimerMode as HrTimerMode>::Expires) -> Self::TimerHandle;
197}
198
199/// Unsafe version of [`HrTimerPointer`] for situations where leaking the
200/// [`HrTimerHandle`] returned by `start` would be unsound. This is the case for
201/// stack allocated timers.
202///
203/// Typical implementers are pinned references such as [`Pin<&T>`].
204///
205/// # Safety
206///
207/// Implementers of this trait must ensure that instances of types implementing
208/// [`UnsafeHrTimerPointer`] outlives any associated [`HrTimerPointer::TimerHandle`]
209/// instances.
210pub unsafe trait UnsafeHrTimerPointer: Sync + Sized {
211    /// The operational mode associated with this timer.
212    ///
213    /// This defines how the expiration value is interpreted.
214    type TimerMode: HrTimerMode;
215
216    /// A handle representing a running timer.
217    ///
218    /// # Safety
219    ///
220    /// If the timer is running, or if the timer callback is executing when the
221    /// handle is dropped, the drop method of [`Self::TimerHandle`] must not return
222    /// until the timer is stopped and the callback has completed.
223    type TimerHandle: HrTimerHandle;
224
225    /// Start the timer after `expires` time units. If the timer was already
226    /// running, it is restarted at the new expiry time.
227    ///
228    /// # Safety
229    ///
230    /// Caller promises keep the timer structure alive until the timer is dead.
231    /// Caller can ensure this by not leaking the returned [`Self::TimerHandle`].
232    unsafe fn start(self, expires: <Self::TimerMode as HrTimerMode>::Expires) -> Self::TimerHandle;
233}
234
235/// A trait for stack allocated timers.
236///
237/// # Safety
238///
239/// Implementers must ensure that `start_scoped` does not return until the
240/// timer is dead and the timer handler is not running.
241pub unsafe trait ScopedHrTimerPointer {
242    /// The operational mode associated with this timer.
243    ///
244    /// This defines how the expiration value is interpreted.
245    type TimerMode: HrTimerMode;
246
247    /// Start the timer to run after `expires` time units and immediately
248    /// after call `f`. When `f` returns, the timer is cancelled.
249    fn start_scoped<T, F>(self, expires: <Self::TimerMode as HrTimerMode>::Expires, f: F) -> T
250    where
251        F: FnOnce() -> T;
252}
253
254// SAFETY: By the safety requirement of [`UnsafeHrTimerPointer`], dropping the
255// handle returned by [`UnsafeHrTimerPointer::start`] ensures that the timer is
256// killed.
257unsafe impl<T> ScopedHrTimerPointer for T
258where
259    T: UnsafeHrTimerPointer,
260{
261    type TimerMode = T::TimerMode;
262
263    fn start_scoped<U, F>(
264        self,
265        expires: <<T as UnsafeHrTimerPointer>::TimerMode as HrTimerMode>::Expires,
266        f: F,
267    ) -> U
268    where
269        F: FnOnce() -> U,
270    {
271        // SAFETY: We drop the timer handle below before returning.
272        let handle = unsafe { UnsafeHrTimerPointer::start(self, expires) };
273        let t = f();
274        drop(handle);
275        t
276    }
277}
278
279/// Implemented by [`HrTimerPointer`] implementers to give the C timer callback a
280/// function to call.
281// This is split from `HrTimerPointer` to make it easier to specify trait bounds.
282pub trait RawHrTimerCallback {
283    /// Type of the parameter passed to [`HrTimerCallback::run`]. It may be
284    /// [`Self`], or a pointer type derived from [`Self`].
285    type CallbackTarget<'a>;
286
287    /// Callback to be called from C when timer fires.
288    ///
289    /// # Safety
290    ///
291    /// Only to be called by C code in the `hrtimer` subsystem. `this` must point
292    /// to the `bindings::hrtimer` structure that was used to start the timer.
293    unsafe extern "C" fn run(this: *mut bindings::hrtimer) -> bindings::hrtimer_restart;
294}
295
296/// Implemented by structs that can be the target of a timer callback.
297pub trait HrTimerCallback {
298    /// The type whose [`RawHrTimerCallback::run`] method will be invoked when
299    /// the timer expires.
300    type Pointer<'a>: RawHrTimerCallback;
301
302    /// Called by the timer logic when the timer fires.
303    fn run(this: <Self::Pointer<'_> as RawHrTimerCallback>::CallbackTarget<'_>) -> HrTimerRestart
304    where
305        Self: Sized;
306}
307
308/// A handle representing a potentially running timer.
309///
310/// More than one handle representing the same timer might exist.
311///
312/// # Safety
313///
314/// When dropped, the timer represented by this handle must be cancelled, if it
315/// is running. If the timer handler is running when the handle is dropped, the
316/// drop method must wait for the handler to return before returning.
317///
318/// Note: One way to satisfy the safety requirement is to call `Self::cancel` in
319/// the drop implementation for `Self.`
320pub unsafe trait HrTimerHandle {
321    /// Cancel the timer. If the timer is in the running state, block till the
322    /// handler has returned.
323    ///
324    /// Note that the timer might be started by a concurrent start operation. If
325    /// so, the timer might not be in the **stopped** state when this function
326    /// returns.
327    fn cancel(&mut self) -> bool;
328}
329
330/// Implemented by structs that contain timer nodes.
331///
332/// Clients of the timer API would usually safely implement this trait by using
333/// the [`crate::impl_has_hr_timer`] macro.
334///
335/// # Safety
336///
337/// Implementers of this trait must ensure that the implementer has a
338/// [`HrTimer`] field and that all trait methods are implemented according to
339/// their documentation. All the methods of this trait must operate on the same
340/// field.
341pub unsafe trait HasHrTimer<T> {
342    /// The operational mode associated with this timer.
343    ///
344    /// This defines how the expiration value is interpreted.
345    type TimerMode: HrTimerMode;
346
347    /// Return a pointer to the [`HrTimer`] within `Self`.
348    ///
349    /// This function is useful to get access to the value without creating
350    /// intermediate references.
351    ///
352    /// # Safety
353    ///
354    /// `this` must be a valid pointer.
355    unsafe fn raw_get_timer(this: *const Self) -> *const HrTimer<T>;
356
357    /// Return a pointer to the struct that is containing the [`HrTimer`] pointed
358    /// to by `ptr`.
359    ///
360    /// This function is useful to get access to the value without creating
361    /// intermediate references.
362    ///
363    /// # Safety
364    ///
365    /// `ptr` must point to a [`HrTimer<T>`] field in a struct of type `Self`.
366    unsafe fn timer_container_of(ptr: *mut HrTimer<T>) -> *mut Self
367    where
368        Self: Sized;
369
370    /// Get pointer to the contained `bindings::hrtimer` struct.
371    ///
372    /// This function is useful to get access to the value without creating
373    /// intermediate references.
374    ///
375    /// # Safety
376    ///
377    /// `this` must be a valid pointer.
378    unsafe fn c_timer_ptr(this: *const Self) -> *const bindings::hrtimer {
379        // SAFETY: `this` is a valid pointer to a `Self`.
380        let timer_ptr = unsafe { Self::raw_get_timer(this) };
381
382        // SAFETY: timer_ptr points to an allocation of at least `HrTimer` size.
383        unsafe { HrTimer::raw_get(timer_ptr) }
384    }
385
386    /// Start the timer contained in the `Self` pointed to by `self_ptr`. If
387    /// it is already running it is removed and inserted.
388    ///
389    /// # Safety
390    ///
391    /// - `this` must point to a valid `Self`.
392    /// - Caller must ensure that the pointee of `this` lives until the timer
393    ///   fires or is canceled.
394    unsafe fn start(this: *const Self, expires: <Self::TimerMode as HrTimerMode>::Expires) {
395        // SAFETY: By function safety requirement, `this` is a valid `Self`.
396        unsafe {
397            bindings::hrtimer_start_range_ns(
398                Self::c_timer_ptr(this).cast_mut(),
399                expires.as_nanos(),
400                0,
401                <Self::TimerMode as HrTimerMode>::C_MODE,
402            );
403        }
404    }
405}
406
407/// Restart policy for timers.
408#[derive(Copy, Clone, PartialEq, Eq, Debug)]
409#[repr(u32)]
410pub enum HrTimerRestart {
411    /// Timer should not be restarted.
412    NoRestart = bindings::hrtimer_restart_HRTIMER_NORESTART,
413    /// Timer should be restarted.
414    Restart = bindings::hrtimer_restart_HRTIMER_RESTART,
415}
416
417impl HrTimerRestart {
418    fn into_c(self) -> bindings::hrtimer_restart {
419        self as bindings::hrtimer_restart
420    }
421}
422
423/// Time representations that can be used as expiration values in [`HrTimer`].
424pub trait HrTimerExpires {
425    /// Converts the expiration time into a nanosecond representation.
426    ///
427    /// This value corresponds to a raw ktime_t value, suitable for passing to kernel
428    /// timer functions. The interpretation (absolute vs relative) depends on the
429    /// associated [HrTimerMode] in use.
430    fn as_nanos(&self) -> i64;
431}
432
433impl<C: ClockSource> HrTimerExpires for Instant<C> {
434    #[inline]
435    fn as_nanos(&self) -> i64 {
436        Instant::<C>::as_nanos(self)
437    }
438}
439
440impl HrTimerExpires for Delta {
441    #[inline]
442    fn as_nanos(&self) -> i64 {
443        Delta::as_nanos(*self)
444    }
445}
446
447mod private {
448    use crate::time::ClockSource;
449
450    pub trait Sealed {}
451
452    impl<C: ClockSource> Sealed for super::AbsoluteMode<C> {}
453    impl<C: ClockSource> Sealed for super::RelativeMode<C> {}
454    impl<C: ClockSource> Sealed for super::AbsolutePinnedMode<C> {}
455    impl<C: ClockSource> Sealed for super::RelativePinnedMode<C> {}
456    impl<C: ClockSource> Sealed for super::AbsoluteSoftMode<C> {}
457    impl<C: ClockSource> Sealed for super::RelativeSoftMode<C> {}
458    impl<C: ClockSource> Sealed for super::AbsolutePinnedSoftMode<C> {}
459    impl<C: ClockSource> Sealed for super::RelativePinnedSoftMode<C> {}
460    impl<C: ClockSource> Sealed for super::AbsoluteHardMode<C> {}
461    impl<C: ClockSource> Sealed for super::RelativeHardMode<C> {}
462    impl<C: ClockSource> Sealed for super::AbsolutePinnedHardMode<C> {}
463    impl<C: ClockSource> Sealed for super::RelativePinnedHardMode<C> {}
464}
465
466/// Operational mode of [`HrTimer`].
467pub trait HrTimerMode: private::Sealed {
468    /// The C representation of hrtimer mode.
469    const C_MODE: bindings::hrtimer_mode;
470
471    /// Type representing the clock source.
472    type Clock: ClockSource;
473
474    /// Type representing the expiration specification (absolute or relative time).
475    type Expires: HrTimerExpires;
476}
477
478/// Timer that expires at a fixed point in time.
479pub struct AbsoluteMode<C: ClockSource>(PhantomData<C>);
480
481impl<C: ClockSource> HrTimerMode for AbsoluteMode<C> {
482    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_ABS;
483
484    type Clock = C;
485    type Expires = Instant<C>;
486}
487
488/// Timer that expires after a delay from now.
489pub struct RelativeMode<C: ClockSource>(PhantomData<C>);
490
491impl<C: ClockSource> HrTimerMode for RelativeMode<C> {
492    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_REL;
493
494    type Clock = C;
495    type Expires = Delta;
496}
497
498/// Timer with absolute expiration time, pinned to its current CPU.
499pub struct AbsolutePinnedMode<C: ClockSource>(PhantomData<C>);
500impl<C: ClockSource> HrTimerMode for AbsolutePinnedMode<C> {
501    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_ABS_PINNED;
502
503    type Clock = C;
504    type Expires = Instant<C>;
505}
506
507/// Timer with relative expiration time, pinned to its current CPU.
508pub struct RelativePinnedMode<C: ClockSource>(PhantomData<C>);
509impl<C: ClockSource> HrTimerMode for RelativePinnedMode<C> {
510    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_REL_PINNED;
511
512    type Clock = C;
513    type Expires = Delta;
514}
515
516/// Timer with absolute expiration, handled in soft irq context.
517pub struct AbsoluteSoftMode<C: ClockSource>(PhantomData<C>);
518impl<C: ClockSource> HrTimerMode for AbsoluteSoftMode<C> {
519    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_ABS_SOFT;
520
521    type Clock = C;
522    type Expires = Instant<C>;
523}
524
525/// Timer with relative expiration, handled in soft irq context.
526pub struct RelativeSoftMode<C: ClockSource>(PhantomData<C>);
527impl<C: ClockSource> HrTimerMode for RelativeSoftMode<C> {
528    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_REL_SOFT;
529
530    type Clock = C;
531    type Expires = Delta;
532}
533
534/// Timer with absolute expiration, pinned to CPU and handled in soft irq context.
535pub struct AbsolutePinnedSoftMode<C: ClockSource>(PhantomData<C>);
536impl<C: ClockSource> HrTimerMode for AbsolutePinnedSoftMode<C> {
537    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_ABS_PINNED_SOFT;
538
539    type Clock = C;
540    type Expires = Instant<C>;
541}
542
543/// Timer with absolute expiration, pinned to CPU and handled in soft irq context.
544pub struct RelativePinnedSoftMode<C: ClockSource>(PhantomData<C>);
545impl<C: ClockSource> HrTimerMode for RelativePinnedSoftMode<C> {
546    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_REL_PINNED_SOFT;
547
548    type Clock = C;
549    type Expires = Delta;
550}
551
552/// Timer with absolute expiration, handled in hard irq context.
553pub struct AbsoluteHardMode<C: ClockSource>(PhantomData<C>);
554impl<C: ClockSource> HrTimerMode for AbsoluteHardMode<C> {
555    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_ABS_HARD;
556
557    type Clock = C;
558    type Expires = Instant<C>;
559}
560
561/// Timer with relative expiration, handled in hard irq context.
562pub struct RelativeHardMode<C: ClockSource>(PhantomData<C>);
563impl<C: ClockSource> HrTimerMode for RelativeHardMode<C> {
564    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_REL_HARD;
565
566    type Clock = C;
567    type Expires = Delta;
568}
569
570/// Timer with absolute expiration, pinned to CPU and handled in hard irq context.
571pub struct AbsolutePinnedHardMode<C: ClockSource>(PhantomData<C>);
572impl<C: ClockSource> HrTimerMode for AbsolutePinnedHardMode<C> {
573    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_ABS_PINNED_HARD;
574
575    type Clock = C;
576    type Expires = Instant<C>;
577}
578
579/// Timer with relative expiration, pinned to CPU and handled in hard irq context.
580pub struct RelativePinnedHardMode<C: ClockSource>(PhantomData<C>);
581impl<C: ClockSource> HrTimerMode for RelativePinnedHardMode<C> {
582    const C_MODE: bindings::hrtimer_mode = bindings::hrtimer_mode_HRTIMER_MODE_REL_PINNED_HARD;
583
584    type Clock = C;
585    type Expires = Delta;
586}
587
588/// Use to implement the [`HasHrTimer<T>`] trait.
589///
590/// See [`module`] documentation for an example.
591///
592/// [`module`]: crate::time::hrtimer
593#[macro_export]
594macro_rules! impl_has_hr_timer {
595    (
596        impl$({$($generics:tt)*})?
597            HasHrTimer<$timer_type:ty>
598            for $self:ty
599        {
600            mode : $mode:ty,
601            field : self.$field:ident $(,)?
602        }
603        $($rest:tt)*
604    ) => {
605        // SAFETY: This implementation of `raw_get_timer` only compiles if the
606        // field has the right type.
607        unsafe impl$(<$($generics)*>)? $crate::time::hrtimer::HasHrTimer<$timer_type> for $self {
608            type TimerMode = $mode;
609
610            #[inline]
611            unsafe fn raw_get_timer(
612                this: *const Self,
613            ) -> *const $crate::time::hrtimer::HrTimer<$timer_type> {
614                // SAFETY: The caller promises that the pointer is not dangling.
615                unsafe { ::core::ptr::addr_of!((*this).$field) }
616            }
617
618            #[inline]
619            unsafe fn timer_container_of(
620                ptr: *mut $crate::time::hrtimer::HrTimer<$timer_type>,
621            ) -> *mut Self {
622                // SAFETY: As per the safety requirement of this function, `ptr`
623                // is pointing inside a `$timer_type`.
624                unsafe { ::kernel::container_of!(ptr, $timer_type, $field) }
625            }
626        }
627    }
628}
629
630mod arc;
631pub use arc::ArcHrTimerHandle;
632mod pin;
633pub use pin::PinHrTimerHandle;
634mod pin_mut;
635pub use pin_mut::PinMutHrTimerHandle;
636// `box` is a reserved keyword, so prefix with `t` for timer
637mod tbox;
638pub use tbox::BoxHrTimerHandle;
kernel/time/hrtimer.rs

kernel/time/
hrtimer.rs
