Hi all,

Today's linux-next merge of the rust tree got a conflict in:

  rust/kernel/ptr.rs

between commit:

  08da98f18f4f9 ("rust: ptr: add `KnownSize` trait to support DST size info extraction")

from the origin tree and commit:

  0a51b384e0dec ("rust: ptr: add const_align_up()")

from the rust tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --cc rust/kernel/ptr.rs
index bdc2d79ff6699,c7788656a1621..0000000000000
--- a/rust/kernel/ptr.rs
+++ b/rust/kernel/ptr.rs
@@@ -2,15 -2,11 +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
@@@ -232,24 -226,31 +232,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,
+     }
+ }

On Fri, Apr 3, 2026 at 2:35 PM Mark Brown <broonie@kernel.org> wrote:
>
>  +use core::mem::{
>  +    align_of,
>  +    size_of, //
>  +};
>   use core::num::NonZero;

Looks good -- it could be nice to take the chance to "merge" these two:

    use core::{
        mem::{
            align_of,
            size_of, //
        },
        num::NonZero, //
    };

Thanks as usual!

Cheers,
Miguel