rust: hrtimer: add clocksource selection through `ClockId` (aa33de03) · Commits · git / linux-nf

rust/kernel/time.rs

+66 −0

Original line number	Diff line number	Diff line
		@@ -83,3 +83,69 @@ fn sub(self, other: Ktime) -> Ktime {
		}
		}
		}

		/// An identifier for a clock. Used when specifying clock sources.
		///
		///
		/// Selection of the clock depends on the use case. In some cases the usage of a
		/// particular clock is mandatory, e.g. in network protocols, filesystems.In other
		/// cases the user of the clock has to decide which clock is best suited for the
		/// purpose. In most scenarios clock [`ClockId::Monotonic`] is the best choice as it
		/// provides a accurate monotonic notion of time (leap second smearing ignored).
		#[derive(Clone, Copy, PartialEq, Eq, Debug)]
		#[repr(u32)]
		pub enum ClockId {
		/// A settable system-wide clock that measures real (i.e., wall-clock) time.
		///
		/// Setting this clock requires appropriate privileges. This clock is
		/// affected by discontinuous jumps in the system time (e.g., if the system
		/// administrator manually changes the clock), and by frequency adjustments
		/// performed by NTP and similar applications via adjtime(3), adjtimex(2),
		/// clock_adjtime(2), and ntp_adjtime(3). This clock normally counts the
		/// number of seconds since 1970-01-01 00:00:00 Coordinated Universal Time
		/// (UTC) except that it ignores leap seconds; near a leap second it may be
		/// adjusted by leap second smearing to stay roughly in sync with UTC. Leap
		/// second smearing applies frequency adjustments to the clock to speed up
		/// or slow down the clock to account for the leap second without
		/// discontinuities in the clock. If leap second smearing is not applied,
		/// the clock will experience discontinuity around leap second adjustment.
		RealTime = bindings::CLOCK_REALTIME,
		/// A monotonically increasing clock.
		///
		/// A nonsettable system-wide clock that represents monotonic time since—as
		/// described by POSIX—"some unspecified point in the past". On Linux, that
		/// point corresponds to the number of seconds that the system has been
		/// running since it was booted.
		///
		/// The CLOCK_MONOTONIC clock is not affected by discontinuous jumps in the
		/// CLOCK_REAL (e.g., if the system administrator manually changes the
		/// clock), but is affected by frequency adjustments. This clock does not
		/// count time that the system is suspended.
		Monotonic = bindings::CLOCK_MONOTONIC,
		/// A monotonic that ticks while system is suspended.
		///
		/// A nonsettable system-wide clock that is identical to CLOCK_MONOTONIC,
		/// except that it also includes any time that the system is suspended. This
		/// allows applications to get a suspend-aware monotonic clock without
		/// having to deal with the complications of CLOCK_REALTIME, which may have
		/// discontinuities if the time is changed using settimeofday(2) or similar.
		BootTime = bindings::CLOCK_BOOTTIME,
		/// International Atomic Time.
		///
		/// A system-wide clock derived from wall-clock time but counting leap seconds.
		///
		/// This clock is coupled to CLOCK_REALTIME and will be set when CLOCK_REALTIME is
		/// set, or when the offset to CLOCK_REALTIME is changed via adjtimex(2). This
		/// usually happens during boot and should not happen during normal operations.
		/// However, if NTP or another application adjusts CLOCK_REALTIME by leap second
		/// smearing, this clock will not be precise during leap second smearing.
		///
		/// The acronym TAI refers to International Atomic Time.
		TAI = bindings::CLOCK_TAI,
		}

		impl ClockId {
		fn into_c(self) -> bindings::clockid_t {
		self as bindings::clockid_t
		}
		}

rust/kernel/time/hrtimer.rs

+3 −2

Original line number	Diff line number	Diff line
		@@ -67,6 +67,7 @@
		//! A `restart` operation on a timer in the stopped state is equivalent to a
		//! `start` operation.

		use super::ClockId;
		use crate::{init::PinInit, prelude::*, time::Ktime, types::Opaque};
		use core::marker::PhantomData;

		@@ -94,7 +95,7 @@ unsafe impl<T> Sync for HrTimer<T> {}

		impl<T> HrTimer<T> {
		/// Return an initializer for a new timer instance.
		pub fn new(mode: HrTimerMode) -> impl PinInit<Self>
		pub fn new(mode: HrTimerMode, clock: ClockId) -> impl PinInit<Self>
		where
		T: HrTimerCallback,
		{
		@@ -108,7 +109,7 @@ pub fn new(mode: HrTimerMode) -> impl PinInit<Self>
		bindings::hrtimer_setup(
		place,
		Some(T::Pointer::run),
		bindings::CLOCK_MONOTONIC as i32,
		clock.into_c(),
		mode.into_c(),
		);
		}