rust: upgrade to Rust 1.74.1
Subsystems (3)
Miguel Ojeda
maintainerPATCH 1/1 rust: upgrade to Rust 1.74.1
This is the next upgrade to the Rust toolchain, from 1.73.0 to 1.74.1 (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
No unstable features (that we use) were stabilized.
Therefore, the only unstable features allowed to be used outside the kernel crate are still new_uninit,offset_of, though other code to be upstreamed may increase the list (e.g. offset_of was added recently).
Please see [3] for details.
# Other improvements
Rust 1.74.0 allows to use #[repr(Rust)] explicitly [4], which can be useful to be explicit about particular cases that would normally use e.g. the C representation, such as silencing lints like the upcoming additions we requested [5] to the no_mangle_with_rust_abi Clippy lint (which in turn triggered the #[repr(Rust)] addition).
Rust 1.74.0 includes a fix for one of the false negative cases we reported in Clippy's disallowed_macros lint [6] that we would like to use in the future.
Rust 1.74.1 fixes an ICE that the Apple AGX GPU driver was hitting [7].
# Required changes
For this upgrade, no changes were required (i.e. on our side).
# 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.
--- Documentation/process/changes.rst | 2 +- rust/alloc/alloc.rs | 32 ++++++++---- rust/alloc/lib.rs | 6 +-- rust/alloc/slice.rs | 2 +- rust/alloc/vec/mod.rs | 87 ++++++++++++++++++++++++++++++- scripts/min-tool-version.sh | 2 +- 6 files changed, 114 insertions(+), 17 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.73.0 rustc --version +Rust (optional) 1.74.1 rustc --version bindgen (optional) 0.65.1 bindgen --version GNU make 3.82 make --version bash 4.2 bash --version
rust/alloc/alloc.rs +23 -9
@@ -345,18 +345,31 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {fn __rust_alloc_error_handler (size:usize , align:usize ) -> !; } -/// Abort on memory allocation error or failure. +/// Signal a memory allocation error. /// -/// Callers of memory allocation APIs wishing to abort computation +/// Callers of memory allocation APIs wishing to cease execution /// in response to an allocation error are encouraged to call this function, -/// rather than directly invoking `panic!` or similar. +/// rather than directly invoking [`panic!`] or similar. /// -/// The default behavior of this function is to print a message to standard error -/// and abort the process. -/// It can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`]. +/// This function is guaranteed to diverge (not return normally with a value), but depending on +/// global configuration, it may either panic (resulting in unwinding or aborting as per +/// configuration for all panics), or abort the process (with no unwinding). +/// +/// The default behavior is: +/// +/// * If the binary links against `std` (typically the case), then +/// print a message to standard error and abort the process. +/// This behavior can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`]. +/// Future versions of Rust may panic by default instead. +/// +/// * If the binary does not link against `std` (all of its crates are marked +/// [`#![no_std]`][no_std]), then call [`panic!`] with a message. +/// [The panic handler] applies as to any panic. /// /// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html /// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html +/// [The panic handler]: https://doc.rust-lang.org/reference/runtime.html#the-panic_handler-attribute +/// [no_std]: https://doc.rust-lang.org/reference/names/preludes.html#the-no_std-attribute #[stable(feature = "global_alloc" , since = "1.28.0" )] #[rustc_const_unstable(feature = "const_alloc_error" , issue = "92523" )] #[cfg(all(not(no_global_oom_handling), not(test)))]
@@ -397,9 +410,10 @@ pub unsafe fn __rdl_oom(size: usize, _align: usize) -> ! {if unsafe { __rust_alloc_error_handler_should_panic !=0 } {panic! ("memory allocation of {size} bytes failed" ) }else { - core::panicking::panic_nounwind_fmt (format_args! ( -"memory allocation of {size} bytes failed" - )) + core::panicking::panic_nounwind_fmt ( +format_args! ("memory allocation of {size} bytes failed" ), +/* force_no_backtrace */ false , + ) } } }
rust/alloc/lib.rs +3 -3
@@ -90,8 +90,8 @@#![warn(missing_docs)] #![allow(explicit_outlives_requirements)] #![warn(multiple_supertrait_upcastable)] -#![cfg_attr(not(bootstrap), allow(internal_features))] -#![cfg_attr(not(bootstrap), allow(rustdoc::redundant_explicit_links))] +#![allow(internal_features)] +#![allow(rustdoc::redundant_explicit_links)] // // Library features: // tidy-alphabetical-start
@@ -122,6 +122,7 @@#![feature(const_waker)] #![feature(core_intrinsics)] #![feature(core_panic)] +#![feature(deprecated_suggestion)] #![feature(dispatch_from_dyn)] #![feature(error_generic_member_access)] #![feature(error_in_core)]
@@ -145,7 +146,6 @@#![feature(ptr_metadata)] #![feature(ptr_sub_ptr)] #![feature(receiver_trait)] -#![feature(saturating_int_impl)] #![feature(set_ptr_value)] #![feature(sized_type_properties)] #![feature(slice_from_ptr_range)]
rust/alloc/slice.rs +1 -1
@@ -594,7 +594,7 @@ pub fn join<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Outp/// ``` #[rustc_allow_incoherent_impl] #[stable(feature = "rust1" , since = "1.0.0" )] -#[deprecated(since = "1.3.0" , note = "renamed to join" )] +#[deprecated(since = "1.3.0" , note = "renamed to join" , suggestion = "join" )] pub fn connect <Separator >(&self, sep:Separator ) -> <Self as Join <Separator >>::Output where Self :Join <Separator >,
rust/alloc/vec/mod.rs +85 -2
126 lines not on this page · raw message
scripts/min-tool-version.sh +1 -1
@@ -31,7 +31,7 @@ llvm) fi ;; rustc) - echo 1.73.0 + echo 1.74.1 ;; bindgen) echo 0.65.1
base-commit: a39b6ac3781d46ba18193c9dbb2110f31e9bffe9
Signature · 1 line
2.43.0
Quoted 9 lines · Miguel Ojeda
This is the next upgrade to the Rust toolchain, from 1.73.0 to 1.74.1 (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").[...]
Quoted 8 lines
Signed-off-by Miguel Ojeda <[email protected]>
Quoted 92 lines · Miguel Ojeda
This is the next upgrade to the Rust toolchain, from 1.73.0 to 1.74.1 (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
No unstable features (that we use) were stabilized.
Therefore, the only unstable features allowed to be used outside the
kernelcrate are stillnew_uninit,offset_of, though other code to be upstreamed may increase the list (e.g.offset_ofwas added recently).Please see [3] for details.
# Other improvements
Rust 1.74.0 allows to use
#[repr(Rust)]explicitly [4], which can be useful to be explicit about particular cases that would normally use e.g. the C representation, such as silencing lints like the upcoming additions we requested [5] to theno_mangle_with_rust_abiClippy lint (which in turn triggered the#[repr(Rust)]addition).Rust 1.74.0 includes a fix for one of the false negative cases we reported in Clippy's
disallowed_macroslint [6] that we would like to use in the future.Rust 1.74.1 fixes an ICE that the Apple AGX GPU driver was hitting [7].
# Required changes
For this upgrade, no changes were required (i.e. on our side).
#
allocupgrade and reviewingThe vast majority of changes are due to our
allocfork 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
allocand 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
allocwe 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 cprust/library/alloc/src/PATHlinux/rust/alloc/PATH
git -C linux diff --patch-with-stat --summary -R > old.patch git -C linux restorerust/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 cprust/library/alloc/src/PATHlinux/rust/alloc/PATH
git -C linux diff --patch-with-stat --summary -R > new.patch git -C linux restorerust/allocNow one may check the
new.patchto 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.Signed-off-by Miguel Ojeda <[email protected]>
Quoted 2 lines
---
[...]
Quoted 93 lines · Miguel Ojeda
This is the next upgrade to the Rust toolchain, from 1.73.0 to 1.74.1 (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
No unstable features (that we use) were stabilized.
Therefore, the only unstable features allowed to be used outside the
kernelcrate are stillnew_uninit,offset_of, though other code to be upstreamed may increase the list (e.g.offset_ofwas added recently).Please see [3] for details.
# Other improvements
Rust 1.74.0 allows to use
#[repr(Rust)]explicitly [4], which can be useful to be explicit about particular cases that would normally use e.g. the C representation, such as silencing lints like the upcoming additions we requested [5] to theno_mangle_with_rust_abiClippy lint (which in turn triggered the#[repr(Rust)]addition).Rust 1.74.0 includes a fix for one of the false negative cases we reported in Clippy's
disallowed_macroslint [6] that we would like to use in the future.Rust 1.74.1 fixes an ICE that the Apple AGX GPU driver was hitting [7].
# Required changes
For this upgrade, no changes were required (i.e. on our side).
#
allocupgrade and reviewingThe vast majority of changes are due to our
allocfork 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
allocand 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
allocwe 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 cprust/library/alloc/src/PATHlinux/rust/alloc/PATH
git -C linux diff --patch-with-stat --summary -R > old.patch git -C linux restorerust/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 cprust/library/alloc/src/PATHlinux/rust/alloc/PATH
git -C linux diff --patch-with-stat --summary -R > new.patch git -C linux restorerust/allocNow one may check the
new.patchto 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.Signed-off-by Miguel Ojeda <[email protected]>
Quoted 1 line
---
KUnit tests pass on x86_64 and UML.
Cheers,
-- David
Quoted 5 lines · Miguel Ojeda
This is the next upgrade to the Rust toolchain, from 1.73.0 to 1.74.1 (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").
[...]
Quoted 9 lines
Signed-off-by Miguel Ojeda <[email protected]>---
Signature · 2 lines
Cheers, Benno
Miguel Ojeda
AppliedQuoted 3 lines · Miguel Ojeda
This is the next upgrade to the Rust toolchain, from 1.73.0 to 1.74.1 (i.e. the latest) [1].
Applied to rust-next -- thanks everyone!
Cheers,
Miguel