lkml.org 
[lkml]   [2023]   [Aug]   [2]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Date
    SubjectRe: [PATCH 1/2] rust: upgrade to Rust 1.71.0
    On Sat, Jul 29, 2023 at 6:05 PM Miguel Ojeda <ojeda@kernel.org> wrote:
    >
    > This is the second upgrade to the Rust toolchain, from 1.68.2 to 1.71.0
    > (i.e. the latest).
    >
    > See the upgrade policy [1] 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 feature allowed to be used outside
    > the `kernel` crate is still `new_uninit`, though other code to be
    > upstreamed may increase the list.
    >
    > Please see [2] for details.
    >
    > # Required changes
    >
    > For the upgrade, this patch requires the following changes:
    >
    > - Removal of the `__rust_*` allocator functions, together with
    > the addition of the `__rust_no_alloc_shim_is_unstable` static.
    > See [3] for details.
    >
    > - Some more compiler builtins added due to `<f{32,64}>::midpoint()`
    > that got added in Rust 1.71 [4].
    >
    > # `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://rust-for-linux.com/rust-version-policy [1]
    > Link: https://github.com/Rust-for-Linux/linux/issues/2 [2]
    > Link: https://github.com/rust-lang/rust/pull/86844 [3]
    > Link: https://github.com/rust-lang/rust/pull/92048 [4]
    > Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
    > [...]

    Reviewed-by: Trevor Gross <tmgross@umich.edu>

    A few highlights since 1.68.2 that may eventually be of use:

    - `CStr::is_empty` and `CStr::from_bytes_until_nul` help smooth FFI a bit
    - `NonNull::slice_from_raw_parts` for slice pointers
    - `AtomicX::as_ptr` makes interop with C more clear (doesn't seem like we
    use these types anywhere yet)
    - const `ptr::read` and `ptr::read_unaligned`
    - `{Option, Result}::is_some_and`
    - `core::cell::OnceCell` one-time initialization
    - `repr(C)` enums now use `c_int` rather than always `i32` (no difference for
    currently supported targets)

    \
     
     \ /
      Last update: 2023-08-02 09:46    [W:5.939 / U:0.100 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site