Skip to contentSkip to conversation

rust: upgrade to Rust 1.77.0

PATCH Applied Miguel Ojeda 5 participants 7 messages Feb 17, 2024 – Mar 29, 2024

Subsystems (4)
lore
Share & tools
lore

Miguel Ojeda

author maintainer
#0 lore raw

PATCH 1/1 rust: upgrade to Rust 1.77.0

This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 (i.e. the latest) [1].

See the upgrade policy [2] and the comments on the first upgrade in commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2").

# Unstable features

The offset_of feature (single-field offset_of!) that we were using got stabilized in Rust 1.77.0 [3].

Therefore, now the only unstable features allowed to be used outside the kernel crate is new_uninit, though other code to be upstreamed may increase the list.

Please see [4] for details.

# Required changes

Rust 1.77.0 merged the unused_tuple_struct_fields lint into dead_code, thus upgrading it from allow to warn [5]. In turn, this makes rustc complain about the ThisModule's pointer field being never read. Thus locally allow it for the moment, since we will have users later on (e.g. Binder needs a as_ptr method [6]).

# Other changes

Rust 1.77.0 introduces the --check-cfg feature [7], for which there is a Call for Testing going on [8]. We were requested to test it and we found it useful [9] -- we will likely enable it in the future.

# alloc upgrade and reviewing

The vast majority of changes are due to our alloc fork being upgraded at once.

There are two kinds of changes to be aware of: the ones coming from upstream, which we should follow as closely as possible, and the updates needed in our added fallible APIs to keep them matching the newer infallible APIs coming from upstream.

Instead of taking a look at the diff of this patch, an alternative approach is reviewing a diff of the changes between upstream alloc and the kernel's. This allows to easily inspect the kernel additions only, especially to check if the fallible methods we already have still match the infallible ones in the new version coming from upstream.

Another approach is reviewing the changes introduced in the additions in the kernel fork between the two versions. This is useful to spot potentially unintended changes to our additions.

To apply these approaches, one may follow steps similar to the following to generate a pair of patches that show the differences between upstream Rust and the kernel (for the subset of alloc we use) before and after applying this patch:

# Get the difference with respect to the old version.
git -C rust checkout $(linux/scripts/min-tool-version.sh rustc) git -C linux ls-tree -r --name-only HEAD -- rust/alloc |
cut -d/ -f3- |
grep -Fv README.md |
xargs -IPATH cp rust/library/alloc/src/PATH linux/rust/alloc/PATH
git -C linux diff --patch-with-stat --summary -R > old.patch git -C linux restore rust/alloc

# Apply this patch.
git -C linux am rust-upgrade.patch

# Get the difference with respect to the new version.
git -C rust checkout $(linux/scripts/min-tool-version.sh rustc) git -C linux ls-tree -r --name-only HEAD -- rust/alloc |
cut -d/ -f3- |
grep -Fv README.md |
xargs -IPATH cp rust/library/alloc/src/PATH linux/rust/alloc/PATH
git -C linux diff --patch-with-stat --summary -R > new.patch git -C linux restore rust/alloc

Now one may check the new.patch to take a look at the additions (first approach) or at the difference between those two patches (second approach). For the latter, a side-by-side tool is recommended.

---
Please note that Rust 1.77.0 will be released in a month (2024-03-21).

 Documentation/process/changes.rst |   2 +-
 rust/alloc/alloc.rs               |   6 +-
 rust/alloc/boxed.rs               |   4 +-
 rust/alloc/lib.rs                 |   7 +-
 rust/alloc/raw_vec.rs             |  13 ++--
 rust/alloc/slice.rs               |   4 +-
 rust/alloc/vec/into_iter.rs       | 104 +++++++++++++++++++-----------
 rust/alloc/vec/mod.rs             | 101 ++++++++++++++++++++---------
 rust/kernel/lib.rs                |   3 +-
 scripts/Makefile.build            |   2 +-
 scripts/min-tool-version.sh       |   2 +-
 11 files changed, 159 insertions(+), 89 deletions(-)
Documentation/process/changes.rst +1 -1
index c78ecc1e176f..0229ba993cff 100644
@@ -31,7 +31,7 @@ you probably needn't concern yourself with pcmciautils.
 ====================== ===============  ========================================
 GNU C                  5.1              gcc --version
 Clang/LLVM (optional)  11.0.0           clang --version
-Rust (optional)        1.76.0           rustc --version
+Rust (optional)        1.77.0           rustc --version
 bindgen (optional)     0.65.1           bindgen --version
 GNU make               3.82             make --version
 bash                   4.2              bash --version
rust/alloc/alloc.rs +3 -3
index abb791cc2371..b1204f87227b 100644
@@ -5,7 +5,7 @@
 #![stable(feature = "alloc_module", since = "1.28.0")]
 
 #[cfg(not(test))]
-use core::intrinsics;
+use core::hint;
 
 #[cfg(not(test))]
 use core::ptr::{self, NonNull};
@@ -210,7 +210,7 @@ unsafe fn grow_impl(
                 let new_size = new_layout.size();
 
                 // `realloc` probably checks for `new_size >= old_layout.size()` or something similar.
-                intrinsics::assume(new_size >= old_layout.size());
+                hint::assert_unchecked(new_size >= old_layout.size());
 
                 let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size);
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
@@ -301,7 +301,7 @@ unsafe fn shrink(
             // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller
             new_size if old_layout.align() == new_layout.align() => unsafe {
                 // `realloc` probably checks for `new_size <= old_layout.size()` or something similar.
-                intrinsics::assume(new_size <= old_layout.size());
+                hint::assert_unchecked(new_size <= old_layout.size());
 
                 let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size);
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
rust/alloc/boxed.rs +2 -2
index c93a22a5c97f..5fc39dfeb8e7 100644
@@ -26,6 +26,7 @@
 //! Creating a recursive data structure:
 //!
 //! ```
+//! ##[allow(dead_code)]
 //! #[derive(Debug)]
 //! enum List<T> {
 //!     Cons(T, Box<List<T>>),
@@ -194,8 +195,7 @@
 #[fundamental]
 #[stable(feature = "rust1", since = "1.0.0")]
 // The declaration of the `Box` struct must be kept in sync with the
-// `alloc::alloc::box_free` function or ICEs will happen. See the comment
-// on `box_free` for more details.
+// compiler or ICEs will happen.
 pub struct Box<
     T: ?Sized,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
rust/alloc/lib.rs +4 -3
index 36f79c075593..39afd55ec074 100644
@@ -105,7 +105,6 @@
 #![feature(allocator_api)]
 #![feature(array_chunks)]
 #![feature(array_into_iter_constructors)]
-#![feature(array_methods)]
 #![feature(array_windows)]
 #![feature(ascii_char)]
 #![feature(assert_matches)]
@@ -122,7 +121,6 @@
 #![feature(const_size_of_val)]
 #![feature(const_waker)]
 #![feature(core_intrinsics)]
-#![feature(core_panic)]
 #![feature(deprecated_suggestion)]
 #![feature(dispatch_from_dyn)]
 #![feature(error_generic_member_access)]
@@ -132,6 +130,7 @@
 #![feature(fmt_internals)]
 #![feature(fn_traits)]
 #![feature(hasher_prefixfree_extras)]
+#![feature(hint_assert_unchecked)]
 #![feature(inline_const)]
 #![feature(inplace_iteration)]
 #![feature(iter_advance_by)]
@@ -141,6 +140,8 @@
 #![feature(maybe_uninit_slice)]
 #![feature(maybe_uninit_uninit_array)]
 #![feature(maybe_uninit_uninit_array_transpose)]
+#![feature(non_null_convenience)]
+#![feature(panic_internals)]
 #![feature(pattern)]
 #![feature(ptr_internals)]
 #![feature(ptr_metadata)]
@@ -149,7 +150,6 @@
 #![feature(set_ptr_value)]
 #![feature(sized_type_properties)]
 #![feature(slice_from_ptr_range)]
-#![feature(slice_group_by)]
 #![feature(slice_ptr_get)]
 #![feature(slice_ptr_len)]
 #![feature(slice_range)]
@@ -182,6 +182,7 @@
 #![feature(const_ptr_write)]
 #![feature(const_trait_impl)]
 #![feature(const_try)]
+#![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
 #![feature(exclusive_range_pattern)]
 #![feature(fundamental)]
rust/alloc/raw_vec.rs +6 -7
index 98b6abf30af6..1839d1c8ee7a 100644
@@ -4,7 +4,7 @@
 
 use core::alloc::LayoutError;
 use core::cmp;
-use core::intrinsics;
+use core::hint;
 use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
 use core::ptr::{self, NonNull, Unique};
 use core::slice;
@@ -317,7 +317,7 @@ fn current_memory(&self) -> Option<(NonNull<u8>, Layout)> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity exceeds `isize::MAX` bytes.
+    /// Panics if the new capacity exceeds `isize::MAX` _bytes_.
     ///
     /// # Aborts
     ///
@@ -358,7 +358,7 @@ pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryRe
         }
         unsafe {
             // Inform the optimizer that the reservation has succeeded or wasn't needed
-            core::intrinsics::assume(!self.needs_to_grow(len, additional));
+            hint::assert_unchecked(!self.needs_to_grow(len, additional));
         }
         Ok(())
     }
@@ -381,7 +381,7 @@ pub fn try_reserve_for_push(&mut self, len: usize) -> Result<(), TryReserveError
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity exceeds `isize::MAX` bytes.
+    /// Panics if the new capacity exceeds `isize::MAX` _bytes_.
     ///
     /// # Aborts
     ///
@@ -402,7 +402,7 @@ pub fn try_reserve_exact(
         }
         unsafe {
             // Inform the optimizer that the reservation has succeeded or wasn't needed
-            core::intrinsics::assume(!self.needs_to_grow(len, additional));
+            hint::assert_unchecked(!self.needs_to_grow(len, additional));
         }
         Ok(())
     }
@@ -553,7 +553,7 @@ fn finish_grow<A>(
         debug_assert_eq!(old_layout.align(), new_layout.align());
         unsafe {
             // The allocator checks for alignment equality
-            intrinsics::assume(old_layout.align() == new_layout.align());
+            hint::assert_unchecked(old_layout.align() == new_layout.align());
             alloc.grow(ptr, old_layout, new_layout)
         }
     } else {
@@ -591,7 +591,6 @@ fn handle_reserve(result: Result<(), TryReserveError>) {
 // `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add
 // an extra guard for this in case we're running on a platform which can use
 // all 4GB in user-space, e.g., PAE or x32.
-
 #[inline]
 fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> {
     if usize::BITS < 64 && alloc_size > isize::MAX as usize {
rust/alloc/slice.rs +2 -2
index 1181836da5f4..a36b072c9519 100644
@@ -53,14 +53,14 @@
 pub use core::slice::{from_mut_ptr_range, from_ptr_range};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::slice::{from_raw_parts, from_raw_parts_mut};
+#[stable(feature = "slice_group_by", since = "1.77.0")]
+pub use core::slice::{ChunkBy, ChunkByMut};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::slice::{Chunks, Windows};
 #[stable(feature = "chunks_exact", since = "1.31.0")]
 pub use core::slice::{ChunksExact, ChunksExactMut};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::slice::{ChunksMut, Split, SplitMut};
-#[unstable(feature = "slice_group_by", issue = "80552")]
-pub use core::slice::{GroupBy, GroupByMut};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::slice::{Iter, IterMut};
 #[stable(feature = "rchunks", since = "1.31.0")]
rust/alloc/vec/into_iter.rs +67 -37

202 lines not on this page · raw message

rust/alloc/vec/mod.rs +71 -30

193 lines not on this page · raw message

rust/kernel/lib.rs +1 -2
index b89ecf4e97a0..80d921f670e3 100644
@@ -16,7 +16,6 @@
 #![feature(coerce_unsized)]
 #![feature(dispatch_from_dyn)]
 #![feature(new_uninit)]
-#![feature(offset_of)]
 #![feature(ptr_metadata)]
 #![feature(receiver_trait)]
 #![feature(unsize)]
@@ -79,7 +78,7 @@ pub trait Module: Sized + Sync {
 /// Equivalent to `THIS_MODULE` in the C API.
 ///
 /// C header: `include/linux/export.h`
-pub struct ThisModule(*mut bindings::module);
+pub struct ThisModule(#[allow(dead_code)] *mut bindings::module);
 
 // SAFETY: `THIS_MODULE` may be used from all threads within a module.
 unsafe impl Sync for ThisModule {}
scripts/Makefile.build +1 -1
index 0fb7a785594c..a5e7aa3ca887 100644
@@ -262,7 +262,7 @@ $(obj)/%.lst: $(src)/%.c FORCE
 # Compile Rust sources (.rs)
 # ---------------------------------------------------------------------------
 
-rust_allowed_features := new_uninit,offset_of
+rust_allowed_features := new_uninit
 
 # `--out-dir` is required to avoid temporaries being created by `rustc` in the
 # current working directory, which may be not accessible in the out-of-tree
scripts/min-tool-version.sh +1 -1
index e217683b10d6..5898e7f5a7f6 100755
@@ -33,7 +33,7 @@ llvm)
 	fi
 	;;
 rustc)
-	echo 1.76.0
+	echo 1.77.0
 	;;
 bindgen)
 	echo 0.65.1

base-commit: 84a0205e9fe88901a68fd5fa24d81846cd880271 --
2.43.0

Tested-by on v1 1/1
#1 lore raw
Quoted 3 lines · Miguel Ojeda

This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 (i.e. the latest) [1].

Again, I've applied this onto the previous 1.76 patch and tested with kunit for x86 and arm64. My toolchain is today's beta:

	> rustc --version
	rustc 1.77.0-beta.4 (d783f371b 2024-02-16

Regards,
Boqun

Quoted 3 lines

See the upgrade policy [2] and the comments on the first upgrade in commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2").

[...]

reviewer Reviewed-by on v1 1/1
#2 lore raw
In reply to Miguel Ojeda
Quoted 18 lines · Miguel Ojeda

This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 (i.e. the latest) [1].

See the upgrade policy [2] and the comments on the first upgrade in commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2").

# Unstable features

The offset_of feature (single-field offset_of!) that we were using got stabilized in Rust 1.77.0 [3].

Therefore, now the only unstable features allowed to be used outside the kernel crate is new_uninit, though other code to be upstreamed may increase the list.

Please see [4] for details.

Quoted 7 lines

# Required changes

Rust 1.77.0 merged the unused_tuple_struct_fields lint into dead_code, thus upgrading it from allow to warn [5]. In turn, this makes rustc complain about the ThisModule's pointer field being never read. Thus locally allow it for the moment, since we will have users later on (e.g. Binder needs a as_ptr method [6]).

Maybe you should just add the as_ptr method to ThisModule now? It will silence the warning, and doesn't trigger a warning of its own since it is pub.

Quoted 7 lines

# Other changes

Rust 1.77.0 introduces the --check-cfg feature [7], for which there is a Call for Testing going on [8]. We were requested to test it and we found it useful [9] -- we will likely enable it in the future.

# alloc upgrade and reviewing

[...]

Quoted 10 lines
#3 lore raw
Quoted 4 lines · Alice Ryhl

Maybe you should just add the as_ptr method to ThisModule now? It will silence the warning, and doesn't trigger a warning of its own since it is pub.

Yeah, either way is fine -- I meant the patch to be independent and to avoid adding an API without a user, but it is not a big deal.

Quoted 1 line

Thanks!

Cheers,
Miguel

#4 lore raw
In reply to Miguel Ojeda
Quoted 2 lines · Miguel Ojeda

This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 (i.e. the latest) [1].

I am a little confused about this patch, since 1.77.0 is not released yet and the link [1] (currently) points to the release notes for 1.76.

Will there be a new version of this patch when 1.77 is released, or do we just expect no changes to alloc when the compiler goes from beta to release?

BR Andreas

#5 lore raw
Quoted 3 lines · Andreas Hindborg (Samsung)

I am a little confused about this patch, since 1.77.0 is not released yet and the link [1] (currently) points to the release notes for 1.76.

Yeah, the patch is written as it would have been written by the time it is applied, i.e. see the note after ---.

So, for instance, the link actually points to the 1.77.0 notes, it is just that they do not exist yet :)

Quoted 3 lines

Will there be a new version of this patch when 1.77 is released, or do we just expect no changes to alloc when the compiler goes from beta to release?

There can changes (or not), so it depends on that, i.e. if not, I will apply this one. If there are non-trivial ones, then I will send a v2.

(There are no changes so far)

Cheers,
Miguel

Applied
#6 lore raw
In reply to Miguel Ojeda
Quoted 3 lines · Miguel Ojeda

This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 (i.e. the latest) [1].

[ Upgraded to 1.77.1. Removed allow(dead_code) thanks to the previous patch. Reworded accordingly. No changes to alloc during the beta. ]

Applied to rust-next -- thanks everyone!

Cheers,
Miguel