rust: upgrade to Rust 1.77.0
Subsystems (4)
Miguel Ojeda
maintainerPATCH 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
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").
[...]
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_offeature (single-fieldoffset_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
kernelcrate isnew_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_fieldslint intodead_code, thus upgrading it fromallowtowarn[5]. In turn, this makesrustccomplain about theThisModule's pointer field being never read. Thus locallyallowit for the moment, since we will have users later on (e.g. Binder needs aas_ptrmethod [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-cfgfeature [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.#
allocupgrade and reviewing
[...]
Quoted 10 lines
Signed-off-by Miguel Ojeda <[email protected]>
Quoted 4 lines · Alice Ryhl
Maybe you should just add the
as_ptrmethod 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
Reviewed-by Alice Ryhl <[email protected]>
Thanks!
Cheers,
Miguel
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
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
Miguel Ojeda
AppliedQuoted 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