linux.git/rust/kernel/time.rs, branch v6.18.21

rust: time: Implement basic arithmetic operations for Delta

2025-09-04T14:56:48+00:00

While rvkms is only going to be using a few of these, since Deltas are
basically the same as i64 it's easy enough to just implement all of the
basic arithmetic operations for Delta types.

Keep in mind there's one quirk here - the kernel has no support for
i64 % i64 on 32 bit platforms, the closest we have is i64 % i32 through
div_s64_rem(). So, instead of implementing ops::Rem or ops::RemAssign we
simply provide Delta::rem_nanos().

Signed-off-by: Lyude Paul 
Reviewed-by: Daniel Almeida 
Reviewed-by: FUJITA Tomonori 
Reviewed-by: Andreas Hindborg 
Link: https://lore.kernel.org/r/20250820203704.731588-3-lyude@redhat.com
Signed-off-by: Andreas Hindborg

rust: time: Implement Add/Sub for Instant

2025-09-04T14:56:48+00:00

In order to copy the behavior rust currently follows for basic arithmetic
operations and panic if the result of an addition or subtraction results in
a value that would violate the invariants of Instant, but only if the
kernel has overflow checking for rust enabled.

Signed-off-by: Lyude Paul 
Reviewed-by: Alice Ryhl 
Reviewed-by: FUJITA Tomonori 
Reviewed-by: Andreas Hindborg 
Reviewed-by: Daniel Almeida 
Link: https://lore.kernel.org/r/20250820203704.731588-2-lyude@redhat.com
Signed-off-by: Andreas Hindborg

rust: hrtimer: Add HrTimer::expires()

2025-09-04T14:54:39+00:00

Add 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.

Signed-off-by: Lyude Paul 
Reviewed-by: Andreas Hindborg 
Link: https://lore.kernel.org/r/20250821193259.964504-8-lyude@redhat.com
Signed-off-by: Andreas Hindborg

rust: time: Add Instant::from_ktime()

2025-09-04T14:54:39+00:00

For implementing Rust bindings which can return a point in time.

Signed-off-by: Lyude Paul 
Reviewed-by: Andreas Hindborg 
Reviewed-by: Alice Ryhl 
Reviewed-by: FUJITA Tomonori 
Link: https://lore.kernel.org/r/20250821193259.964504-7-lyude@redhat.com
Signed-off-by: Andreas Hindborg

rust: time: Add wrapper for fsleep() function

2025-06-30T11:22:05+00:00

Add a wrapper for fsleep(), flexible sleep functions in
include/linux/delay.h which typically deals with hardware delays.

The kernel supports several sleep functions to handle various lengths
of delay. This adds fsleep(), automatically chooses the best sleep
method based on a duration.

fsleep() can only be used in a nonatomic context. This requirement is
not checked by these abstractions, but it is intended that klint [1]
or a similar tool will be used to check it in the future.

Link: https://rust-for-linux.com/klint [1]
Reviewed-by: Gary Guo 
Reviewed-by: Alice Ryhl 
Reviewed-by: Fiona Behrens 
Tested-by: Daniel Almeida 
Reviewed-by: Andreas Hindborg 
Signed-off-by: FUJITA Tomonori 
Link: https://lore.kernel.org/r/20250617144155.3903431-3-fujita.tomonori@gmail.com
Signed-off-by: Andreas Hindborg

rust: time: Add HrTimerExpires trait

2025-06-24T17:52:47+00:00

Introduce the `HrTimerExpires` trait to represent types that can be
used as expiration values for high-resolution timers. Define a
required method, `into_nanos()`, which returns the expiration time as a
raw nanosecond value suitable for use with C's hrtimer APIs.

Also extend the `HrTimerMode` to use the `HrTimerExpires` trait.

This refactoring is a preparation for enabling hrtimer code to work
uniformly with both absolute and relative expiration modes.

Reviewed-by: Andreas Hindborg 
Signed-off-by: FUJITA Tomonori 
Link: https://lore.kernel.org/r/20250610132823.3457263-4-fujita.tomonori@gmail.com
[ changed conversion method names to `as_*` - Andreas ]
Signed-off-by: Andreas Hindborg

rust: time: Add ktime_get() to ClockSource trait

2025-06-16T13:02:29+00:00

Introduce the ktime_get() associated function to the ClockSource
trait, allowing each clock source to specify how it retrieves the
current time. This enables Instant::now() to be implemented
generically using the type-level ClockSource abstraction.

This change enhances the type safety and extensibility of timekeeping
by statically associating time retrieval mechanisms with their
respective clock types. It also reduces the reliance on hardcoded
clock logic within Instant.

Signed-off-by: FUJITA Tomonori 
Link: https://lore.kernel.org/r/20250610093258.3435874-4-fujita.tomonori@gmail.com
Signed-off-by: Andreas Hindborg

rust: time: Make Instant generic over ClockSource

2025-06-16T13:01:56+00:00

Refactor the Instant type to be generic over a ClockSource type
parameter, enabling static enforcement of clock correctness across
APIs that deal with time. Previously, the clock source was implicitly
fixed (typically CLOCK_MONOTONIC), and developers had to ensure
compatibility manually.

This design eliminates runtime mismatches between clock sources, and
enables stronger type-level guarantees throughout the timer subsystem.

Reviewed-by: Andreas Hindborg 
Reviewed-by: Boqun Feng 
Signed-off-by: FUJITA Tomonori 
Link: https://lore.kernel.org/r/20250610093258.3435874-3-fujita.tomonori@gmail.com
Signed-off-by: Andreas Hindborg

rust: time: Replace ClockId enum with ClockSource trait

2025-06-16T13:01:37+00:00

Replace the ClockId enum with a trait-based abstraction called
ClockSource. This change enables expressing clock sources as types and
leveraging the Rust type system to enforce clock correctness at
compile time.

This also sets the stage for future generic abstractions over Instant
types such as Instant.

Reviewed-by: Andreas Hindborg 
Reviewed-by: Boqun Feng 
Signed-off-by: FUJITA Tomonori 
Link: https://lore.kernel.org/r/20250610093258.3435874-2-fujita.tomonori@gmail.com
Signed-off-by: Andreas Hindborg

rust: time: Avoid 64-bit integer division on 32-bit architectures

2025-06-16T13:01:15+00:00

Avoid 64-bit integer division that 32-bit architectures don't
implement generally. This uses ktime_to_us() and ktime_to_ms()
instead.

The time abstraction needs i64 / u32 division so C's div_s64() can be
used but ktime_to_us() and ktime_to_ms() provide a simpler solution
for this time abstraction problem on 32-bit architectures.

32-bit ARM is the only 32-bit architecture currently supported by
Rust. Using the cfg attribute, only 32-bit architectures will call
ktime_to_us() and ktime_to_ms(), while the other 64-bit architectures
will continue to use the current code as-is to avoid the overhead.

One downside of calling the C's functions is that the as_micros/millis
methods can no longer be const fn. We stick with the simpler approach
unless there's a compelling need for a const fn.

Suggested-by: Arnd Bergmann 
Suggested-by: Boqun Feng 
Signed-off-by: FUJITA Tomonori 
Reviewed-by: Andreas Hindborg 
Link: https://lore.kernel.org/r/20250502004524.230553-1-fujita.tomonori@gmail.com
Signed-off-by: Andreas Hindborg