• Miguel Ojeda's avatar
    rust: upgrade to Rust 1.74.1 · 80fe9e51
    Miguel Ojeda authored
    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 3ed03f4d ("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.
    
    Link: https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1741-2023-12-07 [1]
    Link: https://rust-for-linux.com/rust-version-policy [2]
    Link: https://github.com/Rust-for-Linux/linux/issues/2 [3]
    Link: https://github.com/rust-lang/rust/pull/114201 [4]
    Link: https://github.com/rust-lang/rust-clippy/issues/11219 [5]
    Link: https://github.com/rust-lang/rust-clippy/issues/11431 [6]
    Link: https://github.com/rust-lang/rust/issues/117976#issuecomment-1822225691 [7]
    Reviewed-by: default avatarMartin Rodriguez Reboredo <yakoyoku@gmail.com>
    Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
    Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
    Tested-by: default avatarDavid Gow <davidgow@google.com>
    Link: https://lore.kernel.org/r/20231214092958.377061-1-ojeda@kernel.orgSigned-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
    80fe9e51
slice.rs 30.8 KB