Merge tag 'rust-hrtimer-for-v6.15-v3' of https://github.com/Rust-for-Linux/linux into rust-next

F:	kernel/time/timer_migration.*

F:	tools/testing/selftests/timers/

HIGH-RESOLUTION TIMERS [RUST]

M:	Andreas Hindborg <a.hindborg@kernel.org>

R:	Boqun Feng <boqun.feng@gmail.com>

R:	Frederic Weisbecker <frederic@kernel.org>

R:	Lyude Paul <lyude@redhat.com>

R:	Thomas Gleixner <tglx@linutronix.de>

R:	Anna-Maria Behnsen <anna-maria@linutronix.de>

L:	rust-for-linux@vger.kernel.org

S:	Supported

W:	https://rust-for-linux.com

B:	https://github.com/Rust-for-Linux/linux/issues

T:	git https://github.com/Rust-for-Linux/linux.git hrtimer-next

F:	rust/kernel/time/hrtimer.rs

F:	rust/kernel/time/hrtimer/

HIGH-SPEED SCC DRIVER FOR AX.25

L:	linux-hams@vger.kernel.org

S:	Orphan

        Ok(Self::new(x, flags)?.into())

    }

    /// Convert a [`Box<T,A>`] to a [`Pin<Box<T,A>>`]. If `T` does not implement

    /// [`Unpin`], then `x` will be pinned in memory and can't be moved.

    pub fn into_pin(this: Self) -> Pin<Self> {

        this.into()

    }

    /// Forgets the contents (does not run the destructor), but keeps the allocation.

    fn forget_contents(this: Self) -> Box<MaybeUninit<T>, A> {

        let ptr = Self::into_raw(this);

        unsafe { core::ptr::addr_of!((*ptr).data) }

    }

    /// Return a raw pointer to the data in this arc.

    pub fn as_ptr(this: &Self) -> *const T {

        let ptr = this.ptr.as_ptr();

        // SAFETY: As `ptr` points to a valid allocation of type `ArcInner`,

        // field projection to `data`is within bounds of the allocation.

        unsafe { core::ptr::addr_of!((*ptr).data) }

    }

    /// Recreates an [`Arc`] instance previously deconstructed via [`Arc::into_raw`].

    ///

    /// # Safety

    }

    /// Creates an [`ArcBorrow`] to an [`Arc`] that has previously been deconstructed with

    /// [`Arc::into_raw`].

    /// [`Arc::into_raw`] or [`Arc::as_ptr`].

    ///

    /// # Safety

    ///

    /// * The provided pointer must originate from a call to [`Arc::into_raw`].

    /// * The provided pointer must originate from a call to [`Arc::into_raw`] or [`Arc::as_ptr`].

    /// * For the duration of the lifetime annotated on this `ArcBorrow`, the reference count must

    ///   not hit zero.

    /// * For the duration of the lifetime annotated on this `ArcBorrow`, there must not be a

//! C header: [`include/linux/jiffies.h`](srctree/include/linux/jiffies.h).

//! C header: [`include/linux/ktime.h`](srctree/include/linux/ktime.h).

pub mod hrtimer;

/// The number of nanoseconds per millisecond.

pub const NSEC_PER_MSEC: i64 = bindings::NSEC_PER_MSEC as i64;

        }

    }

}

/// 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

    }

}