Re: [PATCH v3 11/13] rust: hrtimer: add `TimerMode`

[Andreas Hindborg <a.hindborg@kernel.org>]

"Lyude Paul" <lyude@redhat.com> writes:

> On Thu, 2024-10-17 at 15:04 +0200, Andreas Hindborg wrote:
>> Allow selection of timer mode by passing a `TimerMode` variant to
>> `Timer::new`.
>>
>> Signed-off-by: Andreas Hindborg <a.hindborg@kernel.org>
>> ---
>>  rust/kernel/hrtimer.rs | 88 +++++++++++++++++++++++++++++++++++++++++++++++---
>>  1 file changed, 84 insertions(+), 4 deletions(-)
>>
>> diff --git a/rust/kernel/hrtimer.rs b/rust/kernel/hrtimer.rs
>> index 2c1573e19576de93afc959d71e94173e2c1ed715..1674d1dcba39cc7ab82e1f189002afa365ee9341 100644
>> --- a/rust/kernel/hrtimer.rs
>> +++ b/rust/kernel/hrtimer.rs
>> @@ -38,12 +38,13 @@
>>  /// # Invariants
>>  ///
>>  /// * `self.timer` is initialized by `bindings::hrtimer_init`.
>> -#[repr(transparent)]
>>  #[pin_data]
>>  #[repr(C)]
>>  pub struct Timer<U> {
>>      #[pin]
>>      timer: Opaque<bindings::hrtimer>,
>> +    // This field goes away when `bindings::hrtimer_setup` is added.
>> +    mode: TimerMode,
>>      _t: PhantomData<U>,
>>  }
>>
>> @@ -56,7 +57,7 @@ unsafe impl<U> Sync for Timer<U> {}
>>
>>  impl<T> Timer<T> {
>>      /// Return an initializer for a new timer instance.
>> -    pub fn new() -> impl PinInit<Self>
>> +    pub fn new(mode: TimerMode) -> impl PinInit<Self>
>>      where
>>          T: TimerCallback,
>>      {
>> @@ -70,7 +71,7 @@ pub fn new() -> impl PinInit<Self>
>>                      bindings::hrtimer_init(
>>                          place,
>>                          bindings::CLOCK_MONOTONIC as i32,
>> -                        bindings::hrtimer_mode_HRTIMER_MODE_REL,
>> +                        mode.into(),
>>                      );
>>                  }
>>
>> @@ -83,6 +84,7 @@ pub fn new() -> impl PinInit<Self>
>>                  // exclusive access.
>>                  unsafe { core::ptr::write(function, Some(T::CallbackTarget::run)) };
>>              }),
>> +            mode: mode,
>>              _t: PhantomData,
>>          })
>>      }
>> @@ -330,7 +332,7 @@ unsafe fn start(self_ptr: *const Self, expires: Ktime) {
>>                  Self::c_timer_ptr(self_ptr).cast_mut(),
>>                  expires.to_ns(),
>>                  0,
>> -                bindings::hrtimer_mode_HRTIMER_MODE_REL,
>> +                (*Self::raw_get_timer(self_ptr)).mode.into(),
>>              );
>>          }
>>      }
>> @@ -362,6 +364,84 @@ fn from(value: TimerRestart) -> Self {
>>      }
>>  }
>>
>> +/// Operational mode of [`Timer`].
>> +#[derive(Clone, Copy)]
>> +pub enum TimerMode {
>> +    /// Timer expires at the given expiration time.
>> +    Absolute,
>> +    /// Timer expires after the given expiration time interpreted as a duration from now.
>> +    Relative,
>> +    /// Timer does not move between CPU cores.
>> +    Pinned,
>> +    /// Timer handler is executed in soft irq context.
>> +    Soft,
>> +    /// Timer handler is executed in hard irq context.
>> +    Hard,
>> +    /// Timer expires at the given expiration time.
>> +    /// Timer does not move between CPU cores.
>> +    AbsolutePinned,
>> +    /// Timer expires after the given expiration time interpreted as a duration from now.
>> +    /// Timer does not move between CPU cores.
>> +    RelativePinned,
>> +    /// Timer expires at the given expiration time.
>> +    /// Timer handler is executed in soft irq context.
>> +    AbsoluteSoft,
>> +    /// Timer expires after the given expiration time interpreted as a duration from now.
>> +    /// Timer handler is executed in soft irq context.
>> +    RelativeSoft,
>> +    /// Timer expires at the given expiration time.
>> +    /// Timer does not move between CPU cores.
>> +    /// Timer handler is executed in soft irq context.
>> +    AbsolutePinnedSoft,
>> +    /// Timer expires after the given expiration time interpreted as a duration from now.
>> +    /// Timer does not move between CPU cores.
>> +    /// Timer handler is executed in soft irq context.
>> +    RelativePinnedSoft,
>> +    /// Timer expires at the given expiration time.
>> +    /// Timer handler is executed in hard irq context.
>> +    AbsoluteHard,
>> +    /// Timer expires after the given expiration time interpreted as a duration from now.
>> +    /// Timer handler is executed in hard irq context.
>> +    RelativeHard,
>> +    /// Timer expires at the given expiration time.
>> +    /// Timer does not move between CPU cores.
>> +    /// Timer handler is executed in hard irq context.
>> +    AbsolutePinnedHard,
>> +    /// Timer expires after the given expiration time interpreted as a duration from now.
>> +    /// Timer does not move between CPU cores.
>> +    /// Timer handler is executed in hard irq context.
>> +    RelativePinnedHard,
>> +}
>> +
>> +impl From<TimerMode> for bindings::hrtimer_mode {
>> +    fn from(value: TimerMode) -> Self {
>> +        use bindings::*;
>> +        match value {
>> +            TimerMode::Absolute => hrtimer_mode_HRTIMER_MODE_ABS,
>> +            TimerMode::Relative => hrtimer_mode_HRTIMER_MODE_REL,
>> +            TimerMode::Pinned => hrtimer_mode_HRTIMER_MODE_PINNED,
>> +            TimerMode::Soft => hrtimer_mode_HRTIMER_MODE_SOFT,
>> +            TimerMode::Hard => hrtimer_mode_HRTIMER_MODE_HARD,
>> +            TimerMode::AbsolutePinned => hrtimer_mode_HRTIMER_MODE_ABS_PINNED,
>> +            TimerMode::RelativePinned => hrtimer_mode_HRTIMER_MODE_REL_PINNED,
>> +            TimerMode::AbsoluteSoft => hrtimer_mode_HRTIMER_MODE_ABS_SOFT,
>> +            TimerMode::RelativeSoft => hrtimer_mode_HRTIMER_MODE_REL_SOFT,
>> +            TimerMode::AbsolutePinnedSoft => hrtimer_mode_HRTIMER_MODE_ABS_PINNED_SOFT,
>> +            TimerMode::RelativePinnedSoft => hrtimer_mode_HRTIMER_MODE_REL_PINNED_SOFT,
>> +            TimerMode::AbsoluteHard => hrtimer_mode_HRTIMER_MODE_ABS_HARD,
>> +            TimerMode::RelativeHard => hrtimer_mode_HRTIMER_MODE_REL_HARD,
>> +            TimerMode::AbsolutePinnedHard => hrtimer_mode_HRTIMER_MODE_ABS_PINNED_HARD,
>> +            TimerMode::RelativePinnedHard => hrtimer_mode_HRTIMER_MODE_REL_PINNED_HARD,
>> +        }
>> +    }
>> +}
>
> Are we sure we actually need to explicitly convert it like this? You should be
> able to use #[repr(…)] to indicate that the enum is the same type as the
> actual C constant, and then we can just assign the value of each C constant as
> the discriminant for each enum value in TimerMode.
>

Some combinations of modes are illegal. With this approach, it is not
possible to name the illegal combinations.

Interesting discussion is happening on Zulip regarding a possible
solution for enums like this [1].


Best regards,
Andreas Hindborg




[1] https://rust-for-linux.zulipchat.com/#narrow/channel/291565-Help/topic/Best.20way.20to.20handle.20enum.2Fflags.20situation