[PATCH v2 4/8] rust: hrtimer: Add HrTimerClockBase

[Lyude Paul]

This adds a simple wrapper for the hrtimer_clock_base struct, which can be
obtained from a HrTimerCallbackContext. We'll use this in the next commit to
add a function to acquire the current time for the base clock driving a
hrtimer.

Signed-off-by: Lyude Paul <lyude@xxxxxxxxxx>

---
V2:
* Convert safety comment to invariant comment in from_raw()
- Add raw_clock_base() and implement clock_base() on HrTimer<T> as well

Signed-off-by: Lyude Paul <lyude@xxxxxxxxxx>
---
 rust/kernel/time/hrtimer.rs | 50 +++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/rust/kernel/time/hrtimer.rs b/rust/kernel/time/hrtimer.rs
index 507fff67f8ab2..a56c66104f692 100644
--- a/rust/kernel/time/hrtimer.rs
+++ b/rust/kernel/time/hrtimer.rs
@@ -183,6 +183,25 @@ unsafe fn raw_forward(self_ptr: *mut Self, now: Instant, interval: Delta) -> u64
         }
     }
 
+    /// Retrieve the [`HrTimerClockBase`] for a given timer pointer.
+    ///
+    /// # Safety
+    ///
+    /// `self_ptr` must point to a valid `Self`.
+    unsafe fn raw_clock_base<'a>(self_ptr: *const Self) -> &'a HrTimerClockBase {
+        // SAFETY:
+        // - By our safety contract, `self_ptr` always points to a valid `HrTimer<T>`.
+        // - `base` is initialized and points to a valid `hrtimer_clock_base` for as long as
+        //   `HrTimer<T>` is exposed to users.
+        unsafe { HrTimerClockBase::from_raw((*Self::raw_get(self_ptr)).base) }
+    }
+
+    /// Retrieve the [`HrTimerClockBase`] for this [`HrTimer`].
+    pub fn clock_base(&self) -> &HrTimerClockBase {
+        // SAFETY: `self` is an immutable reference and thus always points to a valid `HrTimer`
+        unsafe { Self::raw_clock_base(self) }
+    }
+
     /// Forward the timer expiry so it expires at `duration` after `now`.
     ///
     /// This is mainly useful for timer types that can start off providing a mutable reference (e.g.
@@ -200,6 +219,30 @@ pub fn forward(&mut self, now: Instant, duration: Delta) -> u64 {
     }
 }
 
+/// The timer base for a specific clock.
+///
+/// # Invariants
+///
+/// The layout of this type is equivalent to that of `struct hrtimer_clock_base`.
+#[repr(transparent)]
+pub struct HrTimerClockBase(Opaque<bindings::hrtimer_clock_base>);
+
+impl HrTimerClockBase {
+    /// Retrieve a reference to a [`HrTimerClockBase`] from `ptr`.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must point to a live `struct hrtimer_clock_base`.
+    unsafe fn from_raw<'a>(ptr: *mut bindings::hrtimer_clock_base) -> &'a Self {
+        // INVARIANT:
+        // - `ptr` is guaranteed to point to a live `struct hrtimer_clock_base` by our safety
+        //   contract.
+        // SAFETY:
+        // - Our data layout is equivalent to said struct via our type invariants.
+        unsafe { &*ptr.cast() }
+    }
+}
+
 /// Implemented by pointer types that point to structs that contain a [`HrTimer`].
 ///
 /// `Self` must be [`Sync`] because it is passed to timer callbacks in another
@@ -542,6 +585,13 @@ pub(crate) unsafe fn from_raw(timer: *mut HrTimer<T>) -> Self {
         Self(unsafe { NonNull::new_unchecked(timer) }, PhantomData)
     }
 
+    /// Get the [`HrTimerClockBase`] for the [`HrTimer`] associated with this
+    /// [`HrTimerCallbackContext`].
+    pub fn clock_base(&self) -> &HrTimerClockBase {
+        // SAFETY: By our type invariants, `self.0` always points to a valid `HrTimer<T>`.
+        unsafe { HrTimer::<T>::raw_clock_base(self.0.as_ptr()) }
+    }
+
     /// Forward the timer expiry so it expires at `duration` after `now`.
     ///
     /// Note that this does not requeue the timer, it simply updates its expiry value. It returns
-- 
2.48.1