[PATCH v1 1/2] rust: time: make Instant generic over the time unit

[FUJITA Tomonori <tomo@flapping.org>]

From: FUJITA Tomonori <fujita.tomonori@gmail.com>

Add a type parameter `U` to `Instant`, with `Nsec` as the default, so
that an `Instant` in seconds can be added later. The value is stored as
`U::Repr`, like `Delta<U>`.

`U` is bound by a new trait `InstantUnit` rather than `TimeUnit`. It
reads the clock in its unit, and jiffies is not a clock, so
`Instant<C, Jiffy>` must not exist.

`now()` stays one function on `Instant<C, U>`. With two inherent `now()`,
one per unit, the existing `Instant::now()` calls do not compile (E0034,
multiple applicable items). The other methods and operators are
implemented for `Instant<C, Nsec>` only. `Instant<C>` still means
`Instant<C, Nsec>`, so no user changes.

No functional change.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
 rust/kernel/time.rs | 44 ++++++++++++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/rust/kernel/time.rs b/rust/kernel/time.rs
index b6a2aab12a50..8232880bffe7 100644
--- a/rust/kernel/time.rs
+++ b/rust/kernel/time.rs
@@ -179,36 +179,43 @@ fn ktime_get() -> bindings::ktime_t {
 
 /// A specific point in time.
 ///
+/// The time is read from the clock given by the type parameter `C` (see
+/// [`ClockId`]) and stored in the unit given by `U` (see [`InstantUnit`]); its
+/// value has type `U::Repr`. `U` defaults to [`Nsec`], so a plain
+/// [`Instant<C>`] is a point in time in nanoseconds.
+///
 /// # Invariants
 ///
 /// The `inner` value is in the range from 0 to `KTIME_MAX`.
 #[repr(transparent)]
 #[derive(PartialEq, PartialOrd, Eq, Ord)]
-pub struct Instant<C: ClockId> {
-    inner: bindings::ktime_t,
+pub struct Instant<C: ClockId, U: InstantUnit = Nsec> {
+    inner: U::Repr,
     _c: PhantomData<C>,
 }
 
-impl<C: ClockId> Clone for Instant<C> {
+impl<C: ClockId, U: InstantUnit> Clone for Instant<C, U> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<C: ClockId> Copy for Instant<C> {}
+impl<C: ClockId, U: InstantUnit> Copy for Instant<C, U> {}
 
-impl<C: ClockId> Instant<C> {
-    /// Get the current time from the clock source.
+impl<C: ClockId, U: InstantUnit> Instant<C, U> {
+    /// Get the current time from the clock `C`.
     #[inline]
     pub fn now() -> Self {
-        // INVARIANT: The `ClockId::ktime_get()` function returns a value in the range
-        // from 0 to `KTIME_MAX`.
+        // INVARIANT: `InstantUnit` is sealed and its only impl, `Nsec`, calls
+        // `ClockId::ktime_get()`, which returns a value in the range from 0 to `KTIME_MAX`.
         Self {
-            inner: C::ktime_get(),
+            inner: U::now::<C>(),
             _c: PhantomData,
         }
     }
+}
 
+impl<C: ClockId> Instant<C, Nsec> {
     /// Return the amount of time elapsed since the [`Instant`].
     #[inline]
     pub fn elapsed(&self) -> Delta {
@@ -243,7 +250,7 @@ pub(crate) unsafe fn from_ktime(ktime: bindings::ktime_t) -> Self {
     }
 }
 
-impl<C: ClockId> ops::Sub for Instant<C> {
+impl<C: ClockId> ops::Sub for Instant<C, Nsec> {
     type Output = Delta;
 
     // By the type invariant, it never overflows.
@@ -255,7 +262,7 @@ fn sub(self, other: Instant<C>) -> Delta {
     }
 }
 
-impl<T: ClockId> ops::Add<Delta> for Instant<T> {
+impl<T: ClockId> ops::Add<Delta> for Instant<T, Nsec> {
     type Output = Self;
 
     #[inline]
@@ -275,7 +282,7 @@ fn add(self, rhs: Delta) -> Self::Output {
     }
 }
 
-impl<T: ClockId> ops::Sub<Delta> for Instant<T> {
+impl<T: ClockId> ops::Sub<Delta> for Instant<T, Nsec> {
     type Output = Self;
 
     #[inline]
@@ -335,6 +342,19 @@ impl TimeUnit for Jiffy {
     const ZERO: Self::Repr = 0;
 }
 
+/// A trait for time units that can be used with [`Instant`].
+pub trait InstantUnit: TimeUnit {
+    /// Return the current time of the clock `C` in this unit.
+    fn now<C: ClockId>() -> Self::Repr;
+}
+
+impl InstantUnit for Nsec {
+    #[inline]
+    fn now<C: ClockId>() -> i64 {
+        C::ktime_get()
+    }
+}
+
 /// A span of time.
 ///
 /// The span is stored in the unit given by the type parameter `U` (see
-- 
2.43.0