From: Miguel Ojeda <ojeda@kernel.org>
Date: Wed, 8 Apr 2026 07:46:01 +0000 (+0200)
Subject: Merge tag 'rust-timekeeping-for-v7.1' of https://github.com/Rust-for-Linux/linux... 
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=b06b348e855383ed80e041299f3925cdd7dff3da;p=thirdparty%2Fkernel%2Flinux.git

Merge tag 'rust-timekeeping-for-v7.1' of https://github.com/Rust-for-Linux/linux into rust-next

Pull timekeeping updates from Andreas Hindborg:

 - Expand the example section in the 'HrTimer' documentation.

 - Mark the 'ClockSource' trait as unsafe to ensure valid values for
   'ktime_get()'.

 - Add 'Delta::from_nanos()'.

This is a back merge since the pull request has a newer base -- we will
avoid that in the future.

And, given it is a back merge, it happens to resolve the "subtle" conflict
around '--remap-path-{prefix,scope}' that I discussed in linux-next [1],
plus a few other common conflicts. The result matches what we did for
next-20260407.

The actual diffstat (i.e. using a temporary merge of upstream first) is:

    rust/kernel/time.rs         |  32 ++++-
    rust/kernel/time/hrtimer.rs | 336 ++++++++++++++++++++++++++++++++++++++++++++
    2 files changed, 362 insertions(+), 6 deletions(-)

Link: https://lore.kernel.org/linux-next/CANiq72kdxB=W3_CV1U44oOK3SssztPo2wLDZt6LP94TEO+Kj4g@mail.gmail.com/ [1]

* tag 'rust-timekeeping-for-v7.1' of https://github.com/Rust-for-Linux/linux:
  hrtimer: add usage examples to documentation
  rust: time: make ClockSource unsafe trait
  rust/time: Add Delta::from_nanos()
---

b06b348e855383ed80e041299f3925cdd7dff3da
diff --cc rust/Makefile
index 866f9afc1b7f8,9801af2e1e027..bfa1b77c9671d
--- a/rust/Makefile
+++ b/rust/Makefile
@@@ -145,7 -144,12 +145,7 @@@ doctests_modifiers_workaround := $(rust
  quiet_cmd_rustdoc = RUSTDOC $(if $(rustdoc_host),H, ) $<
        cmd_rustdoc = \
  	OBJTREE=$(abspath $(objtree)) \
- 	$(RUSTDOC) $(filter-out $(skip_flags),$(if $(rustdoc_host),$(rust_common_flags),$(rust_flags))) \
 -	$(RUSTDOC) $(filter-out $(skip_flags) --remap-path-prefix=% --remap-path-scope=%, \
 -			$(if $(rustdoc_host),$(rust_common_flags),$(rust_flags))) \
++	$(RUSTDOC) $(filter-out $(skip_flags) --remap-path-scope=%,$(if $(rustdoc_host),$(rust_common_flags),$(rust_flags))) \
  		$(rustc_target_flags) -L$(objtree)/$(obj) \
  		-Zunstable-options --generate-link-to-definition \
  		--output $(rustdoc_output) \
@@@ -329,7 -335,7 +329,7 @@@ quiet_cmd_rustdoc_test_kernel = RUSTDO
  	rm -rf $(objtree)/$(obj)/test/doctests/kernel; \
  	mkdir -p $(objtree)/$(obj)/test/doctests/kernel; \
  	OBJTREE=$(abspath $(objtree)) \
- 	$(RUSTDOC) --test $(rust_flags) \
 -	$(RUSTDOC) --test $(filter-out --remap-path-prefix=% --remap-path-scope=%,$(rust_flags)) \
++	$(RUSTDOC) --test $(filter-out --remap-path-scope=%,$(rust_flags)) \
  		-L$(objtree)/$(obj) --extern ffi --extern pin_init \
  		--extern kernel --extern build_error --extern macros \
  		--extern bindings --extern uapi \
diff --cc rust/kernel/ptr.rs
index 91811f5e27de0,bdc2d79ff6699..3f3e529e9f582
--- a/rust/kernel/ptr.rs
+++ b/rust/kernel/ptr.rs
@@@ -2,11 -2,15 +2,17 @@@
  
  //! Types and functions to work with pointers and addresses.
  
- use core::mem::align_of;
+ pub mod projection;
+ pub use crate::project_pointer as project;
+ 
+ use core::mem::{
+     align_of,
+     size_of, //
+ };
  use core::num::NonZero;
  
 +use crate::const_assert;
 +
  /// Type representing an alignment, which is always a power of two.
  ///
  /// It is used to validate that a given value is a valid alignment, and to perform masking and
@@@ -225,31 -232,24 +231,53 @@@ macro_rules! impl_alignable_uint 
  
  impl_alignable_uint!(u8, u16, u32, u64, usize);
  
+ /// Trait to represent compile-time known size information.
+ ///
+ /// This is a generalization of [`size_of`] that works for dynamically sized types.
+ pub trait KnownSize {
+     /// Get the size of an object of this type in bytes, with the metadata of the given pointer.
+     fn size(p: *const Self) -> usize;
+ }
+ 
+ impl<T> KnownSize for T {
+     #[inline(always)]
+     fn size(_: *const Self) -> usize {
+         size_of::<T>()
+     }
+ }
+ 
+ impl<T> KnownSize for [T] {
+     #[inline(always)]
+     fn size(p: *const Self) -> usize {
+         p.len() * size_of::<T>()
+     }
+ }
++
 +/// Aligns `value` up to `align`.
 +///
 +/// This is the const-compatible equivalent of [`Alignable::align_up`].
 +///
 +/// Returns [`None`] on overflow.
 +///
 +/// # Examples
 +///
 +/// ```
 +/// use kernel::{
 +///     ptr::{
 +///         const_align_up,
 +///         Alignment, //
 +///     },
 +///     sizes::SZ_4K, //
 +/// };
 +///
 +/// assert_eq!(const_align_up(0x4f, Alignment::new::<16>()), Some(0x50));
 +/// assert_eq!(const_align_up(0x40, Alignment::new::<16>()), Some(0x40));
 +/// assert_eq!(const_align_up(1, Alignment::new::<SZ_4K>()), Some(SZ_4K));
 +/// ```
 +#[inline(always)]
 +pub const fn const_align_up(value: usize, align: Alignment) -> Option<usize> {
 +    match value.checked_add(align.as_usize() - 1) {
 +        Some(v) => Some(v & align.mask()),
 +        None => None,
 +    }
 +}