gating behind version 1.83.0

Author: dingxiangfei2009

init/Kconfig

@@ -1964,6 +1964,9 @@ config RUST
 
 	  If unsure, say N.
 
+config RUST_COERCE_POINTEE
+	def_bool y if RUSTC_VERSION >= 108300
+
 config RUSTC_VERSION_TEXT
 	string
 	depends on RUST

rust/kernel/lib.rs

@@ -13,11 +13,13 @@
 
 #![no_std]
 #![feature(arbitrary_self_types)]
-#![feature(coerce_unsized)]
-#![feature(derive_coerce_pointee, pin_coerce_unsized_trait)]
+#![cfg_attr(
+    CONFIG_RUST_COERCE_POINTEE,
+    feature(derive_coerce_pointee, pin_coerce_unsized_trait)
+)]
+#![cfg_attr(not(CONFIG_RUST_COERCE_POINTEE), feature(coerce_unsized, unsize))]
 #![feature(inline_const)]
 #![feature(lint_reasons)]
-#![feature(unsize)]
 
 // Ensure conditional compilation based on the kernel configuration works;
 // otherwise we may silently break things like initcall handling.

rust/kernel/list/arc.rs

@@ -7,10 +7,9 @@
 use crate::alloc::{AllocError, Flags};
 use crate::prelude::*;
 use crate::sync::{Arc, ArcBorrow, UniqueArc};
-use core::marker::CoercePointee;
 use core::marker::PhantomPinned;
 use core::ops::Deref;
-use core::pin::{Pin, PinCoerceUnsized};
+use core::pin::Pin;
 use core::sync::atomic::{AtomicBool, Ordering};
 
 /// Declares that this type has some way to ensure that there is exactly one `ListArc` instance for
@@ -160,7 +159,7 @@ pub use impl_list_arc_safe;
 ///
 /// [`List`]: crate::list::List
 #[repr(transparent)]
-#[derive(CoercePointee)]
+#[cfg_attr(CONFIG_RUST_COERCE_POINTEE, derive(core::marker::CoercePointee))]
 pub struct ListArc<T, const ID: u64 = 0>
 where
     T: ListArcSafe<ID> + ?Sized,
@@ -443,8 +442,32 @@ where
     }
 }
 
+// This is to allow coercion from `ListArc<T>` to `ListArc<U>` if `T` can be converted to the
+// dynamically-sized type (DST) `U`.
+#[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+impl<T, U, const ID: u64> core::ops::CoerceUnsized<ListArc<U, ID>> for ListArc<T, ID>
+where
+    T: ListArcSafe<ID> + Unsize<U> + ?Sized,
+    U: ListArcSafe<ID> + ?Sized,
+{
+}
+
+// This is to allow `ListArc<U>` to be dispatched on when `ListArc<T>` can be coerced into
+// `ListArc<U>`.
+#[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+impl<T, U, const ID: u64> core::ops::DispatchFromDyn<ListArc<U, ID>> for ListArc<T, ID>
+where
+    T: ListArcSafe<ID> + Unsize<U> + ?Sized,
+    U: ListArcSafe<ID> + ?Sized,
+{
+}
+
 /// `ListArc` is well-behaved so that its dereferencing operation does not mutate.
-unsafe impl<T: ?Sized + ListArcSafe<ID>, const ID: u64> PinCoerceUnsized for ListArc<T, ID> {}
+#[cfg(CONFIG_RUST_COERCE_POINTEE)]
+unsafe impl<T: ?Sized + ListArcSafe<ID>, const ID: u64> core::pin::PinCoerceUnsized
+    for ListArc<T, ID>
+{
+}
 
 /// A utility for tracking whether a [`ListArc`] exists using an atomic.
 ///

rust/kernel/sync/arc.rs

@@ -23,10 +23,14 @@ use crate::{
     try_init,
     types::{ForeignOwnable, Opaque},
 };
+#[cfg(CONFIG_RUST_COERCE_POINTEE)]
+use core::marker::CoercePointee;
+#[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+use core::marker::Unsize;
 use core::{
     alloc::Layout,
     fmt,
-    marker::{CoercePointee, PhantomData},
+    marker::PhantomData,
     mem::{ManuallyDrop, MaybeUninit},
     ops::{Deref, DerefMut},
     pin::Pin,
@@ -125,8 +129,8 @@ mod std_vendor;
 /// let coerced: Arc<dyn MyTrait> = obj;
 /// # Ok::<(), Error>(())
 /// ```
-#[repr(transparent)]
-#[derive(CoercePointee)]
+#[cfg_attr(CONFIG_RUST_COERCE_POINTEE, repr(transparent))]
+#[cfg_attr(CONFIG_RUST_COERCE_POINTEE, derive(CoercePointee))]
 pub struct Arc<T: ?Sized> {
     ptr: NonNull<ArcInner<T>>,
     _p: PhantomData<ArcInner<T>>,
@@ -172,6 +176,15 @@ impl<T: ?Sized> ArcInner<T> {
     }
 }
 
+// This is to allow coercion from `Arc<T>` to `Arc<U>` if `T` can be converted to the
+// dynamically-sized type (DST) `U`.
+#[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+impl<T: ?Sized + Unsize<U>, U: ?Sized> core::ops::CoerceUnsized<Arc<U>> for Arc<T> {}
+
+// This is to allow `Arc<U>` to be dispatched on when `Arc<T>` can be coerced into `Arc<U>`.
+#[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+impl<T: ?Sized + Unsize<U>, U: ?Sized> core::ops::DispatchFromDyn<Arc<U>> for Arc<T> {}
+
 // SAFETY: It is safe to send `Arc<T>` to another thread when the underlying `T` is `Sync` because
 // it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally, it needs
 // `T` to be `Send` because any thread that has an `Arc<T>` may ultimately access `T` using a
@@ -466,13 +479,21 @@ impl<T: ?Sized> From<Pin<UniqueArc<T>>> for Arc<T> {
 /// obj.as_arc_borrow().use_reference();
 /// # Ok::<(), Error>(())
 /// ```
-#[repr(transparent)]
-#[derive(CoercePointee)]
+#[cfg_attr(CONFIG_RUST_COERCE_POINTEE, repr(transparent))]
+#[cfg_attr(CONFIG_RUST_COERCE_POINTEE, derive(CoercePointee))]
 pub struct ArcBorrow<'a, T: ?Sized + 'a> {
     inner: NonNull<ArcInner<T>>,
     _p: PhantomData<&'a ()>,
 }
 
+// This is to allow `ArcBorrow<U>` to be dispatched on when `ArcBorrow<T>` can be coerced into
+// `ArcBorrow<U>`.
+#[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+impl<T: ?Sized + Unsize<U>, U: ?Sized> core::ops::DispatchFromDyn<ArcBorrow<'_, U>>
+    for ArcBorrow<'_, T>
+{
+}
+
 impl<T: ?Sized> Clone for ArcBorrow<'_, T> {
     fn clone(&self) -> Self {
         *self

samples/rust/rust_print.rs

@@ -34,25 +34,34 @@ fn arc_print() -> Result {
     // Uses `dbg` to print, will move `c` (for temporary debugging purposes).
     dbg!(c);
 
-    // `Arc` can be used to delegate dynamic dispatch and the following is an example.
-    // Both `i32` and `&str` implements `Display`.
-    // This enables us to express a unified behaviour, contract or protocol on both `i32` and `&str`
-    // in a single `Arc` type `Arc<dyn Display>`.
-    let a_i32_display: Arc<dyn Display> = Arc::new(42i32, GFP_KERNEL)?;
-    let a_str_display: Arc<dyn Display> = a.clone();
-    arc_dyn_print(&a_i32_display);
-    arc_dyn_print(&a_str_display);
+    #[cfg(CONFIG_RUST_COERCE_POINTEE)]
+    {
+        use core::fmt::Display;
+        fn arc_dyn_print(arc: &Arc<dyn Display>) {
+            pr_info!("Arc<dyn Display> says {arc}");
+        }
+        // `Arc` can be used to delegate dynamic dispatch and the following is an example.
+        // Both `i32` and `&str` implements `Display`.
+        // This enables us to express a unified behaviour, contract or protocol on both `i32` and `&str`
+        // in a single `Arc` type `Arc<dyn Display>`.
+        let a_i32_display: Arc<dyn Display> = Arc::new(42i32, GFP_KERNEL)?;
+        let a_str_display: Arc<dyn Display> = a.clone();
+        arc_dyn_print(&a_i32_display);
+        arc_dyn_print(&a_str_display);
+    }
+
+    #[cfg(not(CONFIG_RUST_COERCE_POINTEE))]
+    pr_info!(
+        "The demonstration for dynamic dispatching through Arc is skipped. "
+        "To see the print-out from this example, please upgrade your Rust compiler to 1.83.0 or higher.\n"
+    );
 
     // Pretty-prints the debug formatting with lower-case hexadecimal integers.
     pr_info!("{:#x?}", a);
 
     Ok(())
 }
 
-fn arc_dyn_print(arc: &Arc<dyn Display>) {
-    pr_info!("Arc<dyn Display> says {arc}");
-}
-
 impl kernel::Module for RustPrint {
     fn init(_module: &'static ThisModule) -> Result<Self> {
         pr_info!("Rust printing macros sample (init)\n");