[PATCH 0/2] Rust 1.72.0 upgrade

[PATCH 0/2] Rust 1.72.0 upgrade

[Miguel Ojeda]

This is the third upgrade to the Rust toolchain since the initial Rust
merge, from 1.71.1 to 1.72.0 (i.e. the latest, to be released tomorrow).

Please see the main patch message for a long explanation of the upgrade,
the policy for future upgrades and some indications on how to easily
review this.

The series is based on `rust-next`.

Miguel Ojeda (2):
  rust: arc: add explicit `drop()` around `Box::from_raw()`
  rust: upgrade to Rust 1.72.0

 Documentation/process/changes.rst |   2 +-
 rust/alloc/alloc.rs               |   9 +-
 rust/alloc/boxed.rs               |  10 +-
 rust/alloc/lib.rs                 |  10 +-
 rust/alloc/vec/drain_filter.rs    | 199 ------------------------------
 rust/alloc/vec/extract_if.rs      | 115 +++++++++++++++++
 rust/alloc/vec/mod.rs             | 106 ++++++++--------
 rust/kernel/sync/arc.rs           |   2 +-
 scripts/min-tool-version.sh       |   2 +-
 9 files changed, 188 insertions(+), 267 deletions(-)
 delete mode 100644 rust/alloc/vec/drain_filter.rs
 create mode 100644 rust/alloc/vec/extract_if.rs


base-commit: 4af84c6a85c63bec24611e46bb3de2c0a6602a51
-- 
2.42.0

[PATCH 1/2] rust: arc: add explicit `drop()` around `Box::from_raw()`

[Miguel Ojeda]

`Box::from_raw()` is `#[must_use]`, which means the result cannot
go unused.

In Rust 1.71.0, this was not detected because the block expression
swallows the diagnostic [1]:

    unsafe { Box::from_raw(self.ptr.as_ptr()) };

It would have been detected, however, if the line had been instead:

    unsafe { Box::from_raw(self.ptr.as_ptr()); }

i.e. the semicolon being inside the `unsafe` block, rather than
outside.

In Rust 1.72.0, the compiler started warning about this [2], so
without this patch we will get:

        error: unused return value of `alloc::boxed::Box::<T>::from_raw` that must be used
        --> rust/kernel/sync/arc.rs:302:22
        |
    302 |             unsafe { Box::from_raw(self.ptr.as_ptr()) };
        |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        |
        = note: call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`
        = note: `-D unused-must-use` implied by `-D warnings`
    help: use `let _ = ...` to ignore the resulting value
        |
    302 |             unsafe { let _ = Box::from_raw(self.ptr.as_ptr()); };
        |                      +++++++                                 +

Thus add an add an explicit `drop()` as the `#[must_use]`'s
annotation suggests (instead of the more general help line).

Link: https://github.com/rust-lang/rust/issues/104253 [1]
Link: https://github.com/rust-lang/rust/pull/112529 [2]
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
---
 rust/kernel/sync/arc.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
index 172f563976a9..4c14d540a581 100644
--- a/rust/kernel/sync/arc.rs
+++ b/rust/kernel/sync/arc.rs
@@ -299,7 +299,7 @@ fn drop(&mut self) {
             // The count reached zero, we must free the memory.
             //
             // SAFETY: The pointer was initialised from the result of `Box::leak`.
-            unsafe { Box::from_raw(self.ptr.as_ptr()) };
+            unsafe { drop(Box::from_raw(self.ptr.as_ptr())) };
         }
     }
 }
-- 
2.42.0

Re: [PATCH 1/2] rust: arc: add explicit `drop()` around `Box::from_raw()`

[Björn Roy Baron]

On Wednesday, August 23rd, 2023 at 18:02, Miguel Ojeda <ojeda@kernel.org> wrote:

> `Box::from_raw()` is `#[must_use]`, which means the result cannot
> go unused.
> 
> In Rust 1.71.0, this was not detected because the block expression
> swallows the diagnostic [1]:
> 
>     unsafe { Box::from_raw(self.ptr.as_ptr()) };
> 
> It would have been detected, however, if the line had been instead:
> 
>     unsafe { Box::from_raw(self.ptr.as_ptr()); }
> 
> i.e. the semicolon being inside the `unsafe` block, rather than
> outside.
> 
> In Rust 1.72.0, the compiler started warning about this [2], so
> without this patch we will get:
> 
>         error: unused return value of `alloc::boxed::Box::<T>::from_raw` that must be used
>         --> rust/kernel/sync/arc.rs:302:22
>         |
>     302 |             unsafe { Box::from_raw(self.ptr.as_ptr()) };
>         |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>         |
>         = note: call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`
>         = note: `-D unused-must-use` implied by `-D warnings`
>     help: use `let _ = ...` to ignore the resulting value
>         |
>     302 |             unsafe { let _ = Box::from_raw(self.ptr.as_ptr()); };
>         |                      +++++++                                 +
> 
> Thus add an add an explicit `drop()` as the `#[must_use]`'s
> annotation suggests (instead of the more general help line).
> 
> Link: https://github.com/rust-lang/rust/issues/104253 [1]
> Link: https://github.com/rust-lang/rust/pull/112529 [2]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Björn Roy Baron <bjorn3_gh@protonmail.com>

> ---
>  rust/kernel/sync/arc.rs | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
> index 172f563976a9..4c14d540a581 100644
> --- a/rust/kernel/sync/arc.rs
> +++ b/rust/kernel/sync/arc.rs
> @@ -299,7 +299,7 @@ fn drop(&mut self) {
>              // The count reached zero, we must free the memory.
>              //
>              // SAFETY: The pointer was initialised from the result of `Box::leak`.
> -            unsafe { Box::from_raw(self.ptr.as_ptr()) };
> +            unsafe { drop(Box::from_raw(self.ptr.as_ptr())) };
>          }
>      }
>  }
> --
> 2.42.0

Re: [PATCH 1/2] rust: arc: add explicit `drop()` around `Box::from_raw()`

[Gary Guo]

On Wed, 23 Aug 2023 18:02:42 +0200
Miguel Ojeda <ojeda@kernel.org> wrote:

> `Box::from_raw()` is `#[must_use]`, which means the result cannot
> go unused.
> 
> In Rust 1.71.0, this was not detected because the block expression
> swallows the diagnostic [1]:
> 
>     unsafe { Box::from_raw(self.ptr.as_ptr()) };
> 
> It would have been detected, however, if the line had been instead:
> 
>     unsafe { Box::from_raw(self.ptr.as_ptr()); }
> 
> i.e. the semicolon being inside the `unsafe` block, rather than
> outside.
> 
> In Rust 1.72.0, the compiler started warning about this [2], so
> without this patch we will get:
> 
>         error: unused return value of `alloc::boxed::Box::<T>::from_raw` that must be used
>         --> rust/kernel/sync/arc.rs:302:22  
>         |
>     302 |             unsafe { Box::from_raw(self.ptr.as_ptr()) };
>         |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>         |
>         = note: call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`
>         = note: `-D unused-must-use` implied by `-D warnings`
>     help: use `let _ = ...` to ignore the resulting value
>         |
>     302 |             unsafe { let _ = Box::from_raw(self.ptr.as_ptr()); };
>         |                      +++++++                                 +
> 
> Thus add an add an explicit `drop()` as the `#[must_use]`'s
> annotation suggests (instead of the more general help line).
> 
> Link: https://github.com/rust-lang/rust/issues/104253 [1]
> Link: https://github.com/rust-lang/rust/pull/112529 [2]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Gary Guo <gary@garyguo.net>

> ---
>  rust/kernel/sync/arc.rs | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
> index 172f563976a9..4c14d540a581 100644
> --- a/rust/kernel/sync/arc.rs
> +++ b/rust/kernel/sync/arc.rs
> @@ -299,7 +299,7 @@ fn drop(&mut self) {
>              // The count reached zero, we must free the memory.
>              //
>              // SAFETY: The pointer was initialised from the result of `Box::leak`.
> -            unsafe { Box::from_raw(self.ptr.as_ptr()) };
> +            unsafe { drop(Box::from_raw(self.ptr.as_ptr())) };
>          }
>      }
>  }

Re: [PATCH 1/2] rust: arc: add explicit `drop()` around `Box::from_raw()`

[Martin Rodriguez Reboredo]

On 8/23/23 13:02, Miguel Ojeda wrote:
> `Box::from_raw()` is `#[must_use]`, which means the result cannot
> go unused.
> 
> In Rust 1.71.0, this was not detected because the block expression
> swallows the diagnostic [1]:
> 
>      unsafe { Box::from_raw(self.ptr.as_ptr()) };
> 
> It would have been detected, however, if the line had been instead:
> 
>      unsafe { Box::from_raw(self.ptr.as_ptr()); }
> 
> i.e. the semicolon being inside the `unsafe` block, rather than
> outside.
> 
> In Rust 1.72.0, the compiler started warning about this [2], so
> without this patch we will get:
> 
>          error: unused return value of `alloc::boxed::Box::<T>::from_raw` that must be used
>          --> rust/kernel/sync/arc.rs:302:22
>          |
>      302 |             unsafe { Box::from_raw(self.ptr.as_ptr()) };
>          |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>          |
>          = note: call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`
>          = note: `-D unused-must-use` implied by `-D warnings`
>      help: use `let _ = ...` to ignore the resulting value
>          |
>      302 |             unsafe { let _ = Box::from_raw(self.ptr.as_ptr()); };
>          |                      +++++++                                 +
> 
> Thus add an add an explicit `drop()` as the `#[must_use]`'s
> annotation suggests (instead of the more general help line).
> 
> Link: https://github.com/rust-lang/rust/issues/104253 [1]
> Link: https://github.com/rust-lang/rust/pull/112529 [2]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
> ---
> [...]
Reviewed-by: Martin Rodriguez Reboredo <yakoyoku@gmail.com>

Re: [PATCH 1/2] rust: arc: add explicit `drop()` around `Box::from_raw()`

[Andreas Hindborg]

Miguel Ojeda <ojeda@kernel.org> writes:

> `Box::from_raw()` is `#[must_use]`, which means the result cannot
> go unused.
>
> In Rust 1.71.0, this was not detected because the block expression
> swallows the diagnostic [1]:
>
>     unsafe { Box::from_raw(self.ptr.as_ptr()) };
>
> It would have been detected, however, if the line had been instead:
>
>     unsafe { Box::from_raw(self.ptr.as_ptr()); }
>
> i.e. the semicolon being inside the `unsafe` block, rather than
> outside.
>
> In Rust 1.72.0, the compiler started warning about this [2], so
> without this patch we will get:
>
>         error: unused return value of `alloc::boxed::Box::<T>::from_raw` that must be used
>         --> rust/kernel/sync/arc.rs:302:22
>         |
>     302 |             unsafe { Box::from_raw(self.ptr.as_ptr()) };
>         |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>         |
>         = note: call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`
>         = note: `-D unused-must-use` implied by `-D warnings`
>     help: use `let _ = ...` to ignore the resulting value
>         |
>     302 |             unsafe { let _ = Box::from_raw(self.ptr.as_ptr()); };
>         |                      +++++++                                 +
>
> Thus add an add an explicit `drop()` as the `#[must_use]`'s
> annotation suggests (instead of the more general help line).
>
> Link: https://protect2.fireeye.com/v1/url?k=9e9028e1-ff1b3dd7-9e91a3ae-74fe485cbff1-f2bfda5f7702c68e&q=1&e=66bd90a6-86db-48e7-8538-c118c3f45baa&u=https%3A%2F%2Fgithub.com%2Frust-lang%2Frust%2Fissues%2F104253 [1]
> Link: https://protect2.fireeye.com/v1/url?k=89300613-e8bb1325-89318d5c-74fe485cbff1-fcf76e46b008b25a&q=1&e=66bd90a6-86db-48e7-8538-c118c3f45baa&u=https%3A%2F%2Fgithub.com%2Frust-lang%2Frust%2Fpull%2F112529 [2]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
> ---

Reviewed-by: Andreas Hindborg <a.hindborg@samsung.com>

>  rust/kernel/sync/arc.rs | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
> index 172f563976a9..4c14d540a581 100644
> --- a/rust/kernel/sync/arc.rs
> +++ b/rust/kernel/sync/arc.rs
> @@ -299,7 +299,7 @@ fn drop(&mut self) {
>              // The count reached zero, we must free the memory.
>              //
>              // SAFETY: The pointer was initialised from the result of `Box::leak`.
> -            unsafe { Box::from_raw(self.ptr.as_ptr()) };
> +            unsafe { drop(Box::from_raw(self.ptr.as_ptr())) };
>          }
>      }
>  }

Re: [PATCH 1/2] rust: arc: add explicit `drop()` around `Box::from_raw()`

[Alice Ryhl]

On Wed, Aug 23, 2023 at 6:03 PM Miguel Ojeda <ojeda@kernel.org> wrote:
> `Box::from_raw()` is `#[must_use]`, which means the result cannot
> go unused.
>
> In Rust 1.71.0, this was not detected because the block expression
> swallows the diagnostic [1]:
>
>     unsafe { Box::from_raw(self.ptr.as_ptr()) };
>
> It would have been detected, however, if the line had been instead:
>
>     unsafe { Box::from_raw(self.ptr.as_ptr()); }
>
> i.e. the semicolon being inside the `unsafe` block, rather than
> outside.
>
> In Rust 1.72.0, the compiler started warning about this [2], so
> without this patch we will get:
>
>         error: unused return value of `alloc::boxed::Box::<T>::from_raw` that must be used
>         --> rust/kernel/sync/arc.rs:302:22
>         |
>     302 |             unsafe { Box::from_raw(self.ptr.as_ptr()) };
>         |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>         |
>         = note: call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`
>         = note: `-D unused-must-use` implied by `-D warnings`
>     help: use `let _ = ...` to ignore the resulting value
>         |
>     302 |             unsafe { let _ = Box::from_raw(self.ptr.as_ptr()); };
>         |                      +++++++                                 +
>
> Thus add an add an explicit `drop()` as the `#[must_use]`'s
> annotation suggests (instead of the more general help line).
>
> Link: https://github.com/rust-lang/rust/issues/104253 [1]
> Link: https://github.com/rust-lang/rust/pull/112529 [2]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Alice Ryhl <aliceryhl@google.com>

[PATCH 2/2] rust: upgrade to Rust 1.72.0

[Miguel Ojeda]

This is the second upgrade to the Rust toolchain, from 1.71.1 to 1.72.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

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 [3] for details.

# Other improvements

Previously, the compiler could incorrectly generate a `.eh_frame`
section under `-Cpanic=abort`. We were hitting this bug in our
old `rust` branch [4]. Gary fixed the issue in Rust 1.72.0 [5].

# Required changes

For the upgrade, the following changes are required:

  - A call to `Box::from_raw` in `rust/kernel/sync/arc.rs` now requires
    an explicit `drop()` call. See previous patch for details.

# `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-1720-2023-08-24 [1]
Link: https://rust-for-linux.com/rust-version-policy [2]
Link: https://github.com/Rust-for-Linux/linux/issues/2 [3]
Closes: https://github.com/Rust-for-Linux/linux/issues/1012 [4]
Link: https://github.com/rust-lang/rust/pull/112403 [5]
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
---
 Documentation/process/changes.rst |   2 +-
 rust/alloc/alloc.rs               |   9 +-
 rust/alloc/boxed.rs               |  10 +-
 rust/alloc/lib.rs                 |  10 +-
 rust/alloc/vec/drain_filter.rs    | 199 ------------------------------
 rust/alloc/vec/extract_if.rs      | 115 +++++++++++++++++
 rust/alloc/vec/mod.rs             | 106 ++++++++--------
 scripts/min-tool-version.sh       |   2 +-
 8 files changed, 187 insertions(+), 266 deletions(-)
 delete mode 100644 rust/alloc/vec/drain_filter.rs
 create mode 100644 rust/alloc/vec/extract_if.rs

diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst
index 0bbd040f6a55..1ea95fb5af62 100644
--- a/Documentation/process/changes.rst
+++ b/Documentation/process/changes.rst
@@ -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.71.1           rustc --version
+Rust (optional)        1.72.0           rustc --version
 bindgen (optional)     0.65.1           bindgen --version
 GNU make               3.82             make --version
 bash                   4.2              bash --version
diff --git a/rust/alloc/alloc.rs b/rust/alloc/alloc.rs
index 0b6bf5b6da43..51821feb20b1 100644
--- a/rust/alloc/alloc.rs
+++ b/rust/alloc/alloc.rs
@@ -6,8 +6,10 @@
 
 #[cfg(not(test))]
 use core::intrinsics;
+#[cfg(all(bootstrap, not(test)))]
 use core::intrinsics::{min_align_of_val, size_of_val};
 
+#[cfg(all(bootstrap, not(test)))]
 use core::ptr::Unique;
 #[cfg(not(test))]
 use core::ptr::{self, NonNull};
@@ -40,7 +42,6 @@
     #[rustc_nounwind]
     fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;
 
-    #[cfg(not(bootstrap))]
     static __rust_no_alloc_shim_is_unstable: u8;
 }
 
@@ -98,7 +99,6 @@ pub unsafe fn alloc(layout: Layout) -> *mut u8 {
     unsafe {
         // Make sure we don't accidentally allow omitting the allocator shim in
         // stable code until it is actually stabilized.
-        #[cfg(not(bootstrap))]
         core::ptr::read_volatile(&__rust_no_alloc_shim_is_unstable);
 
         __rust_alloc(layout.size(), layout.align())
@@ -339,14 +339,15 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
     }
 }
 
-#[cfg_attr(not(test), lang = "box_free")]
+#[cfg(all(bootstrap, not(test)))]
+#[lang = "box_free"]
 #[inline]
 // This signature has to be the same as `Box`, otherwise an ICE will happen.
 // When an additional parameter to `Box` is added (like `A: Allocator`), this has to be added here as
 // well.
 // For example if `Box` is changed to  `struct Box<T: ?Sized, A: Allocator>(Unique<T>, A)`,
 // this function has to be changed to `fn box_free<T: ?Sized, A: Allocator>(Unique<T>, A)` as well.
-pub(crate) unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
+unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
     unsafe {
         let size = size_of_val(ptr.as_ref());
         let align = min_align_of_val(ptr.as_ref());
diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs
index c8173cea8317..bdab710f7737 100644
--- a/rust/alloc/boxed.rs
+++ b/rust/alloc/boxed.rs
@@ -1215,8 +1215,16 @@ pub const fn into_pin(boxed: Self) -> Pin<Self>
 
 #[stable(feature = "rust1", since = "1.0.0")]
 unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for Box<T, A> {
+    #[inline]
     fn drop(&mut self) {
-        // FIXME: Do nothing, drop is currently performed by compiler.
+        // the T in the Box is dropped by the compiler before the destructor is run
+
+        let ptr = self.0;
+
+        unsafe {
+            let layout = Layout::for_value_raw(ptr.as_ptr());
+            self.1.deallocate(From::from(ptr.cast()), layout)
+        }
     }
 }
 
diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs
index 85e91356ecb3..115fcb053e73 100644
--- a/rust/alloc/lib.rs
+++ b/rust/alloc/lib.rs
@@ -58,6 +58,11 @@
 //! [`Rc`]: rc
 //! [`RefCell`]: core::cell
 
+// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
+// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
+// rustc itself never sets the feature, so this line has no affect there.
+#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
+//
 #![allow(unused_attributes)]
 #![stable(feature = "alloc", since = "1.36.0")]
 #![doc(
@@ -77,11 +82,6 @@
 ))]
 #![no_std]
 #![needs_allocator]
-// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
-// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
-// rustc itself never sets the feature, so this line has no affect there.
-#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
-//
 // Lints:
 #![deny(unsafe_op_in_unsafe_fn)]
 #![deny(fuzzy_provenance_casts)]
diff --git a/rust/alloc/vec/drain_filter.rs b/rust/alloc/vec/drain_filter.rs
deleted file mode 100644
index 09efff090e42..000000000000
--- a/rust/alloc/vec/drain_filter.rs
+++ /dev/null
@@ -1,199 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0 OR MIT
-
-use crate::alloc::{Allocator, Global};
-use core::mem::{ManuallyDrop, SizedTypeProperties};
-use core::ptr;
-use core::slice;
-
-use super::Vec;
-
-/// An iterator which uses a closure to determine if an element should be removed.
-///
-/// This struct is created by [`Vec::drain_filter`].
-/// See its documentation for more.
-///
-/// # Example
-///
-/// ```
-/// #![feature(drain_filter)]
-///
-/// let mut v = vec![0, 1, 2];
-/// let iter: std::vec::DrainFilter<'_, _, _> = v.drain_filter(|x| *x % 2 == 0);
-/// ```
-#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-#[derive(Debug)]
-pub struct DrainFilter<
-    'a,
-    T,
-    F,
-    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-> where
-    F: FnMut(&mut T) -> bool,
-{
-    pub(super) vec: &'a mut Vec<T, A>,
-    /// The index of the item that will be inspected by the next call to `next`.
-    pub(super) idx: usize,
-    /// The number of items that have been drained (removed) thus far.
-    pub(super) del: usize,
-    /// The original length of `vec` prior to draining.
-    pub(super) old_len: usize,
-    /// The filter test predicate.
-    pub(super) pred: F,
-    /// A flag that indicates a panic has occurred in the filter test predicate.
-    /// This is used as a hint in the drop implementation to prevent consumption
-    /// of the remainder of the `DrainFilter`. Any unprocessed items will be
-    /// backshifted in the `vec`, but no further items will be dropped or
-    /// tested by the filter predicate.
-    pub(super) panic_flag: bool,
-}
-
-impl<T, F, A: Allocator> DrainFilter<'_, T, F, A>
-where
-    F: FnMut(&mut T) -> bool,
-{
-    /// Returns a reference to the underlying allocator.
-    #[unstable(feature = "allocator_api", issue = "32838")]
-    #[inline]
-    pub fn allocator(&self) -> &A {
-        self.vec.allocator()
-    }
-
-    /// Keep unyielded elements in the source `Vec`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(drain_filter)]
-    /// #![feature(drain_keep_rest)]
-    ///
-    /// let mut vec = vec!['a', 'b', 'c'];
-    /// let mut drain = vec.drain_filter(|_| true);
-    ///
-    /// assert_eq!(drain.next().unwrap(), 'a');
-    ///
-    /// // This call keeps 'b' and 'c' in the vec.
-    /// drain.keep_rest();
-    ///
-    /// // If we wouldn't call `keep_rest()`,
-    /// // `vec` would be empty.
-    /// assert_eq!(vec, ['b', 'c']);
-    /// ```
-    #[unstable(feature = "drain_keep_rest", issue = "101122")]
-    pub fn keep_rest(self) {
-        // At this moment layout looks like this:
-        //
-        //  _____________________/-- old_len
-        // /                     \
-        // [kept] [yielded] [tail]
-        //        \_______/ ^-- idx
-        //                \-- del
-        //
-        // Normally `Drop` impl would drop [tail] (via .for_each(drop), ie still calling `pred`)
-        //
-        // 1. Move [tail] after [kept]
-        // 2. Update length of the original vec to `old_len - del`
-        //    a. In case of ZST, this is the only thing we want to do
-        // 3. Do *not* drop self, as everything is put in a consistent state already, there is nothing to do
-        let mut this = ManuallyDrop::new(self);
-
-        unsafe {
-            // ZSTs have no identity, so we don't need to move them around.
-            if !T::IS_ZST && this.idx < this.old_len && this.del > 0 {
-                let ptr = this.vec.as_mut_ptr();
-                let src = ptr.add(this.idx);
-                let dst = src.sub(this.del);
-                let tail_len = this.old_len - this.idx;
-                src.copy_to(dst, tail_len);
-            }
-
-            let new_len = this.old_len - this.del;
-            this.vec.set_len(new_len);
-        }
-    }
-}
-
-#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A>
-where
-    F: FnMut(&mut T) -> bool,
-{
-    type Item = T;
-
-    fn next(&mut self) -> Option<T> {
-        unsafe {
-            while self.idx < self.old_len {
-                let i = self.idx;
-                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
-                self.panic_flag = true;
-                let drained = (self.pred)(&mut v[i]);
-                self.panic_flag = false;
-                // Update the index *after* the predicate is called. If the index
-                // is updated prior and the predicate panics, the element at this
-                // index would be leaked.
-                self.idx += 1;
-                if drained {
-                    self.del += 1;
-                    return Some(ptr::read(&v[i]));
-                } else if self.del > 0 {
-                    let del = self.del;
-                    let src: *const T = &v[i];
-                    let dst: *mut T = &mut v[i - del];
-                    ptr::copy_nonoverlapping(src, dst, 1);
-                }
-            }
-            None
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.old_len - self.idx))
-    }
-}
-
-#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-impl<T, F, A: Allocator> Drop for DrainFilter<'_, T, F, A>
-where
-    F: FnMut(&mut T) -> bool,
-{
-    fn drop(&mut self) {
-        struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator>
-        where
-            F: FnMut(&mut T) -> bool,
-        {
-            drain: &'b mut DrainFilter<'a, T, F, A>,
-        }
-
-        impl<'a, 'b, T, F, A: Allocator> Drop for BackshiftOnDrop<'a, 'b, T, F, A>
-        where
-            F: FnMut(&mut T) -> bool,
-        {
-            fn drop(&mut self) {
-                unsafe {
-                    if self.drain.idx < self.drain.old_len && self.drain.del > 0 {
-                        // This is a pretty messed up state, and there isn't really an
-                        // obviously right thing to do. We don't want to keep trying
-                        // to execute `pred`, so we just backshift all the unprocessed
-                        // elements and tell the vec that they still exist. The backshift
-                        // is required to prevent a double-drop of the last successfully
-                        // drained item prior to a panic in the predicate.
-                        let ptr = self.drain.vec.as_mut_ptr();
-                        let src = ptr.add(self.drain.idx);
-                        let dst = src.sub(self.drain.del);
-                        let tail_len = self.drain.old_len - self.drain.idx;
-                        src.copy_to(dst, tail_len);
-                    }
-                    self.drain.vec.set_len(self.drain.old_len - self.drain.del);
-                }
-            }
-        }
-
-        let backshift = BackshiftOnDrop { drain: self };
-
-        // Attempt to consume any remaining elements if the filter predicate
-        // has not yet panicked. We'll backshift any remaining elements
-        // whether we've already panicked or if the consumption here panics.
-        if !backshift.drain.panic_flag {
-            backshift.drain.for_each(drop);
-        }
-    }
-}
diff --git a/rust/alloc/vec/extract_if.rs b/rust/alloc/vec/extract_if.rs
new file mode 100644
index 000000000000..f314a51d4d3d
--- /dev/null
+++ b/rust/alloc/vec/extract_if.rs
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use crate::alloc::{Allocator, Global};
+use core::ptr;
+use core::slice;
+
+use super::Vec;
+
+/// An iterator which uses a closure to determine if an element should be removed.
+///
+/// This struct is created by [`Vec::extract_if`].
+/// See its documentation for more.
+///
+/// # Example
+///
+/// ```
+/// #![feature(extract_if)]
+///
+/// let mut v = vec![0, 1, 2];
+/// let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(|x| *x % 2 == 0);
+/// ```
+#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[derive(Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
+pub struct ExtractIf<
+    'a,
+    T,
+    F,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> where
+    F: FnMut(&mut T) -> bool,
+{
+    pub(super) vec: &'a mut Vec<T, A>,
+    /// The index of the item that will be inspected by the next call to `next`.
+    pub(super) idx: usize,
+    /// The number of items that have been drained (removed) thus far.
+    pub(super) del: usize,
+    /// The original length of `vec` prior to draining.
+    pub(super) old_len: usize,
+    /// The filter test predicate.
+    pub(super) pred: F,
+}
+
+impl<T, F, A: Allocator> ExtractIf<'_, T, F, A>
+where
+    F: FnMut(&mut T) -> bool,
+{
+    /// Returns a reference to the underlying allocator.
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    #[inline]
+    pub fn allocator(&self) -> &A {
+        self.vec.allocator()
+    }
+}
+
+#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
+where
+    F: FnMut(&mut T) -> bool,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        unsafe {
+            while self.idx < self.old_len {
+                let i = self.idx;
+                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
+                let drained = (self.pred)(&mut v[i]);
+                // Update the index *after* the predicate is called. If the index
+                // is updated prior and the predicate panics, the element at this
+                // index would be leaked.
+                self.idx += 1;
+                if drained {
+                    self.del += 1;
+                    return Some(ptr::read(&v[i]));
+                } else if self.del > 0 {
+                    let del = self.del;
+                    let src: *const T = &v[i];
+                    let dst: *mut T = &mut v[i - del];
+                    ptr::copy_nonoverlapping(src, dst, 1);
+                }
+            }
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, Some(self.old_len - self.idx))
+    }
+}
+
+#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
+where
+    F: FnMut(&mut T) -> bool,
+{
+    fn drop(&mut self) {
+        unsafe {
+            if self.idx < self.old_len && self.del > 0 {
+                // This is a pretty messed up state, and there isn't really an
+                // obviously right thing to do. We don't want to keep trying
+                // to execute `pred`, so we just backshift all the unprocessed
+                // elements and tell the vec that they still exist. The backshift
+                // is required to prevent a double-drop of the last successfully
+                // drained item prior to a panic in the predicate.
+                let ptr = self.vec.as_mut_ptr();
+                let src = ptr.add(self.idx);
+                let dst = src.sub(self.del);
+                let tail_len = self.old_len - self.idx;
+                src.copy_to(dst, tail_len);
+            }
+            self.vec.set_len(self.old_len - self.del);
+        }
+    }
+}
diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs
index 05c70de0227e..a4e9a5002a6d 100644
--- a/rust/alloc/vec/mod.rs
+++ b/rust/alloc/vec/mod.rs
@@ -74,10 +74,10 @@
 use crate::collections::{TryReserveError, TryReserveErrorKind};
 use crate::raw_vec::RawVec;
 
-#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-pub use self::drain_filter::DrainFilter;
+#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+pub use self::extract_if::ExtractIf;
 
-mod drain_filter;
+mod extract_if;
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "vec_splice", since = "1.21.0")]
@@ -618,22 +618,20 @@ pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError> {
     /// Using memory that was allocated elsewhere:
     ///
     /// ```rust
-    /// #![feature(allocator_api)]
-    ///
-    /// use std::alloc::{AllocError, Allocator, Global, Layout};
+    /// use std::alloc::{alloc, Layout};
     ///
     /// fn main() {
     ///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
     ///
     ///     let vec = unsafe {
-    ///         let mem = match Global.allocate(layout) {
-    ///             Ok(mem) => mem.cast::<u32>().as_ptr(),
-    ///             Err(AllocError) => return,
-    ///         };
+    ///         let mem = alloc(layout).cast::<u32>();
+    ///         if mem.is_null() {
+    ///             return;
+    ///         }
     ///
     ///         mem.write(1_000_000);
     ///
-    ///         Vec::from_raw_parts_in(mem, 1, 16, Global)
+    ///         Vec::from_raw_parts(mem, 1, 16)
     ///     };
     ///
     ///     assert_eq!(vec, &[1_000_000]);
@@ -876,19 +874,22 @@ pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserv
     /// Using memory that was allocated elsewhere:
     ///
     /// ```rust
-    /// use std::alloc::{alloc, Layout};
+    /// #![feature(allocator_api)]
+    ///
+    /// use std::alloc::{AllocError, Allocator, Global, Layout};
     ///
     /// fn main() {
     ///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
+    ///
     ///     let vec = unsafe {
-    ///         let mem = alloc(layout).cast::<u32>();
-    ///         if mem.is_null() {
-    ///             return;
-    ///         }
+    ///         let mem = match Global.allocate(layout) {
+    ///             Ok(mem) => mem.cast::<u32>().as_ptr(),
+    ///             Err(AllocError) => return,
+    ///         };
     ///
     ///         mem.write(1_000_000);
     ///
-    ///         Vec::from_raw_parts(mem, 1, 16)
+    ///         Vec::from_raw_parts_in(mem, 1, 16, Global)
     ///     };
     ///
     ///     assert_eq!(vec, &[1_000_000]);
@@ -2507,7 +2508,7 @@ pub fn resize(&mut self, new_len: usize, value: T) {
         let len = self.len();
 
         if new_len > len {
-            self.extend_with(new_len - len, ExtendElement(value))
+            self.extend_with(new_len - len, value)
         } else {
             self.truncate(new_len);
         }
@@ -2545,7 +2546,7 @@ pub fn try_resize(&mut self, new_len: usize, value: T) -> Result<(), TryReserveE
         let len = self.len();
 
         if new_len > len {
-            self.try_extend_with(new_len - len, ExtendElement(value))
+            self.try_extend_with(new_len - len, value)
         } else {
             self.truncate(new_len);
             Ok(())
@@ -2684,26 +2685,10 @@ pub fn into_flattened(self) -> Vec<T, A> {
     }
 }
 
-// This code generalizes `extend_with_{element,default}`.
-trait ExtendWith<T> {
-    fn next(&mut self) -> T;
-    fn last(self) -> T;
-}
-
-struct ExtendElement<T>(T);
-impl<T: Clone> ExtendWith<T> for ExtendElement<T> {
-    fn next(&mut self) -> T {
-        self.0.clone()
-    }
-    fn last(self) -> T {
-        self.0
-    }
-}
-
-impl<T, A: Allocator> Vec<T, A> {
+impl<T: Clone, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
-    /// Extend the vector by `n` values, using the given generator.
-    fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
+    /// Extend the vector by `n` clones of value.
+    fn extend_with(&mut self, n: usize, value: T) {
         self.reserve(n);
 
         unsafe {
@@ -2715,15 +2700,15 @@ fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
 
             // Write all elements except the last one
             for _ in 1..n {
-                ptr::write(ptr, value.next());
+                ptr::write(ptr, value.clone());
                 ptr = ptr.add(1);
-                // Increment the length in every step in case next() panics
+                // Increment the length in every step in case clone() panics
                 local_len.increment_len(1);
             }
 
             if n > 0 {
                 // We can write the last element directly without cloning needlessly
-                ptr::write(ptr, value.last());
+                ptr::write(ptr, value);
                 local_len.increment_len(1);
             }
 
@@ -2731,8 +2716,8 @@ fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
         }
     }
 
-    /// Try to extend the vector by `n` values, using the given generator.
-    fn try_extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) -> Result<(), TryReserveError> {
+    /// Try to extend the vector by `n` clones of value.
+    fn try_extend_with(&mut self, n: usize, value: T) -> Result<(), TryReserveError> {
         self.try_reserve(n)?;
 
         unsafe {
@@ -2744,15 +2729,15 @@ fn try_extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) -> Resul
 
             // Write all elements except the last one
             for _ in 1..n {
-                ptr::write(ptr, value.next());
+                ptr::write(ptr, value.clone());
                 ptr = ptr.add(1);
-                // Increment the length in every step in case next() panics
+                // Increment the length in every step in case clone() panics
                 local_len.increment_len(1);
             }
 
             if n > 0 {
                 // We can write the last element directly without cloning needlessly
-                ptr::write(ptr, value.last());
+                ptr::write(ptr, value);
                 local_len.increment_len(1);
             }
 
@@ -3210,6 +3195,12 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
     /// If the closure returns false, the element will remain in the vector and will not be yielded
     /// by the iterator.
     ///
+    /// If the returned `ExtractIf` is not exhausted, e.g. because it is dropped without iterating
+    /// or the iteration short-circuits, then the remaining elements will be retained.
+    /// Use [`retain`] with a negated predicate if you do not need the returned iterator.
+    ///
+    /// [`retain`]: Vec::retain
+    ///
     /// Using this method is equivalent to the following code:
     ///
     /// ```
@@ -3228,10 +3219,10 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
     /// # assert_eq!(vec, vec![1, 4, 5]);
     /// ```
     ///
-    /// But `drain_filter` is easier to use. `drain_filter` is also more efficient,
+    /// But `extract_if` is easier to use. `extract_if` is also more efficient,
     /// because it can backshift the elements of the array in bulk.
     ///
-    /// Note that `drain_filter` also lets you mutate every element in the filter closure,
+    /// Note that `extract_if` also lets you mutate every element in the filter closure,
     /// regardless of whether you choose to keep or remove it.
     ///
     /// # Examples
@@ -3239,17 +3230,17 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
     /// Splitting an array into evens and odds, reusing the original allocation:
     ///
     /// ```
-    /// #![feature(drain_filter)]
+    /// #![feature(extract_if)]
     /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
     ///
-    /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
+    /// let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<Vec<_>>();
     /// let odds = numbers;
     ///
     /// assert_eq!(evens, vec![2, 4, 6, 8, 14]);
     /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
     /// ```
-    #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-    pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
+    #[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+    pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A>
     where
         F: FnMut(&mut T) -> bool,
     {
@@ -3260,7 +3251,7 @@ pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
             self.set_len(0);
         }
 
-        DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false }
+        ExtractIf { vec: self, idx: 0, del: 0, old_len, pred: filter }
     }
 }
 
@@ -3290,9 +3281,14 @@ fn extend_reserve(&mut self, additional: usize) {
 
 /// Implements comparison of vectors, [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd, A: Allocator> PartialOrd for Vec<T, A> {
+impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
+where
+    T: PartialOrd,
+    A1: Allocator,
+    A2: Allocator,
+{
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &Vec<T, A2>) -> Option<Ordering> {
         PartialOrd::partial_cmp(&**self, &**other)
     }
 }
diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh
index d65ab8bfeaf4..9520612dd398 100755
--- a/scripts/min-tool-version.sh
+++ b/scripts/min-tool-version.sh
@@ -31,7 +31,7 @@ llvm)
 	fi
 	;;
 rustc)
-	echo 1.71.1
+	echo 1.72.0
 	;;
 bindgen)
 	echo 0.65.1
-- 
2.42.0

Re: [PATCH 2/2] rust: upgrade to Rust 1.72.0

[Björn Roy Baron]

On Wednesday, August 23rd, 2023 at 18:02, Miguel Ojeda <ojeda@kernel.org> wrote:

> This is the second upgrade to the Rust toolchain, from 1.71.1 to 1.72.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
> 
> 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 [3] for details.
> 
> # Other improvements
> 
> Previously, the compiler could incorrectly generate a `.eh_frame`
> section under `-Cpanic=abort`. We were hitting this bug in our
> old `rust` branch [4]. Gary fixed the issue in Rust 1.72.0 [5].
> 
> # Required changes
> 
> For the upgrade, the following changes are required:
> 
>   - A call to `Box::from_raw` in `rust/kernel/sync/arc.rs` now requires
>     an explicit `drop()` call. See previous patch for details.
> 
> # `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-1720-2023-08-24 [1]
> Link: https://rust-for-linux.com/rust-version-policy [2]
> Link: https://github.com/Rust-for-Linux/linux/issues/2 [3]
> Closes: https://github.com/Rust-for-Linux/linux/issues/1012 [4]
> Link: https://github.com/rust-lang/rust/pull/112403 [5]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Björn Roy Baron <bjorn3_gh@protonmail.com>

> ---
>  Documentation/process/changes.rst |   2 +-
>  rust/alloc/alloc.rs               |   9 +-
>  rust/alloc/boxed.rs               |  10 +-
>  rust/alloc/lib.rs                 |  10 +-
>  rust/alloc/vec/drain_filter.rs    | 199 ------------------------------
>  rust/alloc/vec/extract_if.rs      | 115 +++++++++++++++++
>  rust/alloc/vec/mod.rs             | 106 ++++++++--------
>  scripts/min-tool-version.sh       |   2 +-
>  8 files changed, 187 insertions(+), 266 deletions(-)
>  delete mode 100644 rust/alloc/vec/drain_filter.rs
>  create mode 100644 rust/alloc/vec/extract_if.rs
> 
> diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst
> index 0bbd040f6a55..1ea95fb5af62 100644
> --- a/Documentation/process/changes.rst
> +++ b/Documentation/process/changes.rst
> @@ -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.71.1           rustc --version
> +Rust (optional)        1.72.0           rustc --version
>  bindgen (optional)     0.65.1           bindgen --version
>  GNU make               3.82             make --version
>  bash                   4.2              bash --version
> diff --git a/rust/alloc/alloc.rs b/rust/alloc/alloc.rs
> index 0b6bf5b6da43..51821feb20b1 100644
> --- a/rust/alloc/alloc.rs
> +++ b/rust/alloc/alloc.rs
> @@ -6,8 +6,10 @@
> 
>  #[cfg(not(test))]
>  use core::intrinsics;
> +#[cfg(all(bootstrap, not(test)))]
>  use core::intrinsics::{min_align_of_val, size_of_val};
> 
> +#[cfg(all(bootstrap, not(test)))]
>  use core::ptr::Unique;
>  #[cfg(not(test))]
>  use core::ptr::{self, NonNull};
> @@ -40,7 +42,6 @@
>      #[rustc_nounwind]
>      fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;
> 
> -    #[cfg(not(bootstrap))]
>      static __rust_no_alloc_shim_is_unstable: u8;
>  }
> 
> @@ -98,7 +99,6 @@ pub unsafe fn alloc(layout: Layout) -> *mut u8 {
>      unsafe {
>          // Make sure we don't accidentally allow omitting the allocator shim in
>          // stable code until it is actually stabilized.
> -        #[cfg(not(bootstrap))]
>          core::ptr::read_volatile(&__rust_no_alloc_shim_is_unstable);
> 
>          __rust_alloc(layout.size(), layout.align())
> @@ -339,14 +339,15 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
>      }
>  }
> 
> -#[cfg_attr(not(test), lang = "box_free")]
> +#[cfg(all(bootstrap, not(test)))]
> +#[lang = "box_free"]
>  #[inline]
>  // This signature has to be the same as `Box`, otherwise an ICE will happen.
>  // When an additional parameter to `Box` is added (like `A: Allocator`), this has to be added here as
>  // well.
>  // For example if `Box` is changed to  `struct Box<T: ?Sized, A: Allocator>(Unique<T>, A)`,
>  // this function has to be changed to `fn box_free<T: ?Sized, A: Allocator>(Unique<T>, A)` as well.
> -pub(crate) unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
> +unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
>      unsafe {
>          let size = size_of_val(ptr.as_ref());
>          let align = min_align_of_val(ptr.as_ref());
> diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs
> index c8173cea8317..bdab710f7737 100644
> --- a/rust/alloc/boxed.rs
> +++ b/rust/alloc/boxed.rs
> @@ -1215,8 +1215,16 @@ pub const fn into_pin(boxed: Self) -> Pin<Self>
> 
>  #[stable(feature = "rust1", since = "1.0.0")]
>  unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for Box<T, A> {
> +    #[inline]
>      fn drop(&mut self) {
> -        // FIXME: Do nothing, drop is currently performed by compiler.
> +        // the T in the Box is dropped by the compiler before the destructor is run
> +
> +        let ptr = self.0;
> +
> +        unsafe {
> +            let layout = Layout::for_value_raw(ptr.as_ptr());
> +            self.1.deallocate(From::from(ptr.cast()), layout)
> +        }
>      }
>  }
> 
> diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs
> index 85e91356ecb3..115fcb053e73 100644
> --- a/rust/alloc/lib.rs
> +++ b/rust/alloc/lib.rs
> @@ -58,6 +58,11 @@
>  //! [`Rc`]: rc
>  //! [`RefCell`]: core::cell
> 
> +// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
> +// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
> +// rustc itself never sets the feature, so this line has no affect there.
> +#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
> +//
>  #![allow(unused_attributes)]
>  #![stable(feature = "alloc", since = "1.36.0")]
>  #![doc(
> @@ -77,11 +82,6 @@
>  ))]
>  #![no_std]
>  #![needs_allocator]
> -// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
> -// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
> -// rustc itself never sets the feature, so this line has no affect there.
> -#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
> -//
>  // Lints:
>  #![deny(unsafe_op_in_unsafe_fn)]
>  #![deny(fuzzy_provenance_casts)]
> diff --git a/rust/alloc/vec/drain_filter.rs b/rust/alloc/vec/drain_filter.rs
> deleted file mode 100644
> index 09efff090e42..000000000000
> --- a/rust/alloc/vec/drain_filter.rs
> +++ /dev/null
> @@ -1,199 +0,0 @@
> -// SPDX-License-Identifier: Apache-2.0 OR MIT
> -
> -use crate::alloc::{Allocator, Global};
> -use core::mem::{ManuallyDrop, SizedTypeProperties};
> -use core::ptr;
> -use core::slice;
> -
> -use super::Vec;
> -
> -/// An iterator which uses a closure to determine if an element should be removed.
> -///
> -/// This struct is created by [`Vec::drain_filter`].
> -/// See its documentation for more.
> -///
> -/// # Example
> -///
> -/// ```
> -/// #![feature(drain_filter)]
> -///
> -/// let mut v = vec![0, 1, 2];
> -/// let iter: std::vec::DrainFilter<'_, _, _> = v.drain_filter(|x| *x % 2 == 0);
> -/// ```
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -#[derive(Debug)]
> -pub struct DrainFilter<
> -    'a,
> -    T,
> -    F,
> -    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> -> where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    pub(super) vec: &'a mut Vec<T, A>,
> -    /// The index of the item that will be inspected by the next call to `next`.
> -    pub(super) idx: usize,
> -    /// The number of items that have been drained (removed) thus far.
> -    pub(super) del: usize,
> -    /// The original length of `vec` prior to draining.
> -    pub(super) old_len: usize,
> -    /// The filter test predicate.
> -    pub(super) pred: F,
> -    /// A flag that indicates a panic has occurred in the filter test predicate.
> -    /// This is used as a hint in the drop implementation to prevent consumption
> -    /// of the remainder of the `DrainFilter`. Any unprocessed items will be
> -    /// backshifted in the `vec`, but no further items will be dropped or
> -    /// tested by the filter predicate.
> -    pub(super) panic_flag: bool,
> -}
> -
> -impl<T, F, A: Allocator> DrainFilter<'_, T, F, A>
> -where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    /// Returns a reference to the underlying allocator.
> -    #[unstable(feature = "allocator_api", issue = "32838")]
> -    #[inline]
> -    pub fn allocator(&self) -> &A {
> -        self.vec.allocator()
> -    }
> -
> -    /// Keep unyielded elements in the source `Vec`.
> -    ///
> -    /// # Examples
> -    ///
> -    /// ```
> -    /// #![feature(drain_filter)]
> -    /// #![feature(drain_keep_rest)]
> -    ///
> -    /// let mut vec = vec!['a', 'b', 'c'];
> -    /// let mut drain = vec.drain_filter(|_| true);
> -    ///
> -    /// assert_eq!(drain.next().unwrap(), 'a');
> -    ///
> -    /// // This call keeps 'b' and 'c' in the vec.
> -    /// drain.keep_rest();
> -    ///
> -    /// // If we wouldn't call `keep_rest()`,
> -    /// // `vec` would be empty.
> -    /// assert_eq!(vec, ['b', 'c']);
> -    /// ```
> -    #[unstable(feature = "drain_keep_rest", issue = "101122")]
> -    pub fn keep_rest(self) {
> -        // At this moment layout looks like this:
> -        //
> -        //  _____________________/-- old_len
> -        // /                     \
> -        // [kept] [yielded] [tail]
> -        //        \_______/ ^-- idx
> -        //                \-- del
> -        //
> -        // Normally `Drop` impl would drop [tail] (via .for_each(drop), ie still calling `pred`)
> -        //
> -        // 1. Move [tail] after [kept]
> -        // 2. Update length of the original vec to `old_len - del`
> -        //    a. In case of ZST, this is the only thing we want to do
> -        // 3. Do *not* drop self, as everything is put in a consistent state already, there is nothing to do
> -        let mut this = ManuallyDrop::new(self);
> -
> -        unsafe {
> -            // ZSTs have no identity, so we don't need to move them around.
> -            if !T::IS_ZST && this.idx < this.old_len && this.del > 0 {
> -                let ptr = this.vec.as_mut_ptr();
> -                let src = ptr.add(this.idx);
> -                let dst = src.sub(this.del);
> -                let tail_len = this.old_len - this.idx;
> -                src.copy_to(dst, tail_len);
> -            }
> -
> -            let new_len = this.old_len - this.del;
> -            this.vec.set_len(new_len);
> -        }
> -    }
> -}
> -
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A>
> -where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    type Item = T;
> -
> -    fn next(&mut self) -> Option<T> {
> -        unsafe {
> -            while self.idx < self.old_len {
> -                let i = self.idx;
> -                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
> -                self.panic_flag = true;
> -                let drained = (self.pred)(&mut v[i]);
> -                self.panic_flag = false;
> -                // Update the index *after* the predicate is called. If the index
> -                // is updated prior and the predicate panics, the element at this
> -                // index would be leaked.
> -                self.idx += 1;
> -                if drained {
> -                    self.del += 1;
> -                    return Some(ptr::read(&v[i]));
> -                } else if self.del > 0 {
> -                    let del = self.del;
> -                    let src: *const T = &v[i];
> -                    let dst: *mut T = &mut v[i - del];
> -                    ptr::copy_nonoverlapping(src, dst, 1);
> -                }
> -            }
> -            None
> -        }
> -    }
> -
> -    fn size_hint(&self) -> (usize, Option<usize>) {
> -        (0, Some(self.old_len - self.idx))
> -    }
> -}
> -
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -impl<T, F, A: Allocator> Drop for DrainFilter<'_, T, F, A>
> -where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    fn drop(&mut self) {
> -        struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator>
> -        where
> -            F: FnMut(&mut T) -> bool,
> -        {
> -            drain: &'b mut DrainFilter<'a, T, F, A>,
> -        }
> -
> -        impl<'a, 'b, T, F, A: Allocator> Drop for BackshiftOnDrop<'a, 'b, T, F, A>
> -        where
> -            F: FnMut(&mut T) -> bool,
> -        {
> -            fn drop(&mut self) {
> -                unsafe {
> -                    if self.drain.idx < self.drain.old_len && self.drain.del > 0 {
> -                        // This is a pretty messed up state, and there isn't really an
> -                        // obviously right thing to do. We don't want to keep trying
> -                        // to execute `pred`, so we just backshift all the unprocessed
> -                        // elements and tell the vec that they still exist. The backshift
> -                        // is required to prevent a double-drop of the last successfully
> -                        // drained item prior to a panic in the predicate.
> -                        let ptr = self.drain.vec.as_mut_ptr();
> -                        let src = ptr.add(self.drain.idx);
> -                        let dst = src.sub(self.drain.del);
> -                        let tail_len = self.drain.old_len - self.drain.idx;
> -                        src.copy_to(dst, tail_len);
> -                    }
> -                    self.drain.vec.set_len(self.drain.old_len - self.drain.del);
> -                }
> -            }
> -        }
> -
> -        let backshift = BackshiftOnDrop { drain: self };
> -
> -        // Attempt to consume any remaining elements if the filter predicate
> -        // has not yet panicked. We'll backshift any remaining elements
> -        // whether we've already panicked or if the consumption here panics.
> -        if !backshift.drain.panic_flag {
> -            backshift.drain.for_each(drop);
> -        }
> -    }
> -}
> diff --git a/rust/alloc/vec/extract_if.rs b/rust/alloc/vec/extract_if.rs
> new file mode 100644
> index 000000000000..f314a51d4d3d
> --- /dev/null
> +++ b/rust/alloc/vec/extract_if.rs
> @@ -0,0 +1,115 @@
> +// SPDX-License-Identifier: Apache-2.0 OR MIT
> +
> +use crate::alloc::{Allocator, Global};
> +use core::ptr;
> +use core::slice;
> +
> +use super::Vec;
> +
> +/// An iterator which uses a closure to determine if an element should be removed.
> +///
> +/// This struct is created by [`Vec::extract_if`].
> +/// See its documentation for more.
> +///
> +/// # Example
> +///
> +/// ```
> +/// #![feature(extract_if)]
> +///
> +/// let mut v = vec![0, 1, 2];
> +/// let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(|x| *x % 2 == 0);
> +/// ```
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +#[derive(Debug)]
> +#[must_use = "iterators are lazy and do nothing unless consumed"]
> +pub struct ExtractIf<
> +    'a,
> +    T,
> +    F,
> +    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> +> where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    pub(super) vec: &'a mut Vec<T, A>,
> +    /// The index of the item that will be inspected by the next call to `next`.
> +    pub(super) idx: usize,
> +    /// The number of items that have been drained (removed) thus far.
> +    pub(super) del: usize,
> +    /// The original length of `vec` prior to draining.
> +    pub(super) old_len: usize,
> +    /// The filter test predicate.
> +    pub(super) pred: F,
> +}
> +
> +impl<T, F, A: Allocator> ExtractIf<'_, T, F, A>
> +where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    /// Returns a reference to the underlying allocator.
> +    #[unstable(feature = "allocator_api", issue = "32838")]
> +    #[inline]
> +    pub fn allocator(&self) -> &A {
> +        self.vec.allocator()
> +    }
> +}
> +
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
> +where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    type Item = T;
> +
> +    fn next(&mut self) -> Option<T> {
> +        unsafe {
> +            while self.idx < self.old_len {
> +                let i = self.idx;
> +                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
> +                let drained = (self.pred)(&mut v[i]);
> +                // Update the index *after* the predicate is called. If the index
> +                // is updated prior and the predicate panics, the element at this
> +                // index would be leaked.
> +                self.idx += 1;
> +                if drained {
> +                    self.del += 1;
> +                    return Some(ptr::read(&v[i]));
> +                } else if self.del > 0 {
> +                    let del = self.del;
> +                    let src: *const T = &v[i];
> +                    let dst: *mut T = &mut v[i - del];
> +                    ptr::copy_nonoverlapping(src, dst, 1);
> +                }
> +            }
> +            None
> +        }
> +    }
> +
> +    fn size_hint(&self) -> (usize, Option<usize>) {
> +        (0, Some(self.old_len - self.idx))
> +    }
> +}
> +
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
> +where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    fn drop(&mut self) {
> +        unsafe {
> +            if self.idx < self.old_len && self.del > 0 {
> +                // This is a pretty messed up state, and there isn't really an
> +                // obviously right thing to do. We don't want to keep trying
> +                // to execute `pred`, so we just backshift all the unprocessed
> +                // elements and tell the vec that they still exist. The backshift
> +                // is required to prevent a double-drop of the last successfully
> +                // drained item prior to a panic in the predicate.
> +                let ptr = self.vec.as_mut_ptr();
> +                let src = ptr.add(self.idx);
> +                let dst = src.sub(self.del);
> +                let tail_len = self.old_len - self.idx;
> +                src.copy_to(dst, tail_len);
> +            }
> +            self.vec.set_len(self.old_len - self.del);
> +        }
> +    }
> +}
> diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs
> index 05c70de0227e..a4e9a5002a6d 100644
> --- a/rust/alloc/vec/mod.rs
> +++ b/rust/alloc/vec/mod.rs
> @@ -74,10 +74,10 @@
>  use crate::collections::{TryReserveError, TryReserveErrorKind};
>  use crate::raw_vec::RawVec;
> 
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -pub use self::drain_filter::DrainFilter;
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +pub use self::extract_if::ExtractIf;
> 
> -mod drain_filter;
> +mod extract_if;
> 
>  #[cfg(not(no_global_oom_handling))]
>  #[stable(feature = "vec_splice", since = "1.21.0")]
> @@ -618,22 +618,20 @@ pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError> {
>      /// Using memory that was allocated elsewhere:
>      ///
>      /// ```rust
> -    /// #![feature(allocator_api)]
> -    ///
> -    /// use std::alloc::{AllocError, Allocator, Global, Layout};
> +    /// use std::alloc::{alloc, Layout};
>      ///
>      /// fn main() {
>      ///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
>      ///
>      ///     let vec = unsafe {
> -    ///         let mem = match Global.allocate(layout) {
> -    ///             Ok(mem) => mem.cast::<u32>().as_ptr(),
> -    ///             Err(AllocError) => return,
> -    ///         };
> +    ///         let mem = alloc(layout).cast::<u32>();
> +    ///         if mem.is_null() {
> +    ///             return;
> +    ///         }
>      ///
>      ///         mem.write(1_000_000);
>      ///
> -    ///         Vec::from_raw_parts_in(mem, 1, 16, Global)
> +    ///         Vec::from_raw_parts(mem, 1, 16)
>      ///     };
>      ///
>      ///     assert_eq!(vec, &[1_000_000]);
> @@ -876,19 +874,22 @@ pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserv
>      /// Using memory that was allocated elsewhere:
>      ///
>      /// ```rust
> -    /// use std::alloc::{alloc, Layout};
> +    /// #![feature(allocator_api)]
> +    ///
> +    /// use std::alloc::{AllocError, Allocator, Global, Layout};
>      ///
>      /// fn main() {
>      ///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
> +    ///
>      ///     let vec = unsafe {
> -    ///         let mem = alloc(layout).cast::<u32>();
> -    ///         if mem.is_null() {
> -    ///             return;
> -    ///         }
> +    ///         let mem = match Global.allocate(layout) {
> +    ///             Ok(mem) => mem.cast::<u32>().as_ptr(),
> +    ///             Err(AllocError) => return,
> +    ///         };
>      ///
>      ///         mem.write(1_000_000);
>      ///
> -    ///         Vec::from_raw_parts(mem, 1, 16)
> +    ///         Vec::from_raw_parts_in(mem, 1, 16, Global)
>      ///     };
>      ///
>      ///     assert_eq!(vec, &[1_000_000]);
> @@ -2507,7 +2508,7 @@ pub fn resize(&mut self, new_len: usize, value: T) {
>          let len = self.len();
> 
>          if new_len > len {
> -            self.extend_with(new_len - len, ExtendElement(value))
> +            self.extend_with(new_len - len, value)
>          } else {
>              self.truncate(new_len);
>          }
> @@ -2545,7 +2546,7 @@ pub fn try_resize(&mut self, new_len: usize, value: T) -> Result<(), TryReserveE
>          let len = self.len();
> 
>          if new_len > len {
> -            self.try_extend_with(new_len - len, ExtendElement(value))
> +            self.try_extend_with(new_len - len, value)
>          } else {
>              self.truncate(new_len);
>              Ok(())
> @@ -2684,26 +2685,10 @@ pub fn into_flattened(self) -> Vec<T, A> {
>      }
>  }
> 
> -// This code generalizes `extend_with_{element,default}`.
> -trait ExtendWith<T> {
> -    fn next(&mut self) -> T;
> -    fn last(self) -> T;
> -}
> -
> -struct ExtendElement<T>(T);
> -impl<T: Clone> ExtendWith<T> for ExtendElement<T> {
> -    fn next(&mut self) -> T {
> -        self.0.clone()
> -    }
> -    fn last(self) -> T {
> -        self.0
> -    }
> -}
> -
> -impl<T, A: Allocator> Vec<T, A> {
> +impl<T: Clone, A: Allocator> Vec<T, A> {
>      #[cfg(not(no_global_oom_handling))]
> -    /// Extend the vector by `n` values, using the given generator.
> -    fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
> +    /// Extend the vector by `n` clones of value.
> +    fn extend_with(&mut self, n: usize, value: T) {
>          self.reserve(n);
> 
>          unsafe {
> @@ -2715,15 +2700,15 @@ fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
> 
>              // Write all elements except the last one
>              for _ in 1..n {
> -                ptr::write(ptr, value.next());
> +                ptr::write(ptr, value.clone());
>                  ptr = ptr.add(1);
> -                // Increment the length in every step in case next() panics
> +                // Increment the length in every step in case clone() panics
>                  local_len.increment_len(1);
>              }
> 
>              if n > 0 {
>                  // We can write the last element directly without cloning needlessly
> -                ptr::write(ptr, value.last());
> +                ptr::write(ptr, value);
>                  local_len.increment_len(1);
>              }
> 
> @@ -2731,8 +2716,8 @@ fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
>          }
>      }
> 
> -    /// Try to extend the vector by `n` values, using the given generator.
> -    fn try_extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) -> Result<(), TryReserveError> {
> +    /// Try to extend the vector by `n` clones of value.
> +    fn try_extend_with(&mut self, n: usize, value: T) -> Result<(), TryReserveError> {
>          self.try_reserve(n)?;
> 
>          unsafe {
> @@ -2744,15 +2729,15 @@ fn try_extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) -> Resul
> 
>              // Write all elements except the last one
>              for _ in 1..n {
> -                ptr::write(ptr, value.next());
> +                ptr::write(ptr, value.clone());
>                  ptr = ptr.add(1);
> -                // Increment the length in every step in case next() panics
> +                // Increment the length in every step in case clone() panics
>                  local_len.increment_len(1);
>              }
> 
>              if n > 0 {
>                  // We can write the last element directly without cloning needlessly
> -                ptr::write(ptr, value.last());
> +                ptr::write(ptr, value);
>                  local_len.increment_len(1);
>              }
> 
> @@ -3210,6 +3195,12 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
>      /// If the closure returns false, the element will remain in the vector and will not be yielded
>      /// by the iterator.
>      ///
> +    /// If the returned `ExtractIf` is not exhausted, e.g. because it is dropped without iterating
> +    /// or the iteration short-circuits, then the remaining elements will be retained.
> +    /// Use [`retain`] with a negated predicate if you do not need the returned iterator.
> +    ///
> +    /// [`retain`]: Vec::retain
> +    ///
>      /// Using this method is equivalent to the following code:
>      ///
>      /// ```
> @@ -3228,10 +3219,10 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
>      /// # assert_eq!(vec, vec![1, 4, 5]);
>      /// ```
>      ///
> -    /// But `drain_filter` is easier to use. `drain_filter` is also more efficient,
> +    /// But `extract_if` is easier to use. `extract_if` is also more efficient,
>      /// because it can backshift the elements of the array in bulk.
>      ///
> -    /// Note that `drain_filter` also lets you mutate every element in the filter closure,
> +    /// Note that `extract_if` also lets you mutate every element in the filter closure,
>      /// regardless of whether you choose to keep or remove it.
>      ///
>      /// # Examples
> @@ -3239,17 +3230,17 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
>      /// Splitting an array into evens and odds, reusing the original allocation:
>      ///
>      /// ```
> -    /// #![feature(drain_filter)]
> +    /// #![feature(extract_if)]
>      /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
>      ///
> -    /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
> +    /// let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<Vec<_>>();
>      /// let odds = numbers;
>      ///
>      /// assert_eq!(evens, vec![2, 4, 6, 8, 14]);
>      /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
>      /// ```
> -    #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -    pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
> +    #[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +    pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A>
>      where
>          F: FnMut(&mut T) -> bool,
>      {
> @@ -3260,7 +3251,7 @@ pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
>              self.set_len(0);
>          }
> 
> -        DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false }
> +        ExtractIf { vec: self, idx: 0, del: 0, old_len, pred: filter }
>      }
>  }
> 
> @@ -3290,9 +3281,14 @@ fn extend_reserve(&mut self, additional: usize) {
> 
>  /// Implements comparison of vectors, [lexicographically](Ord#lexicographical-comparison).
>  #[stable(feature = "rust1", since = "1.0.0")]
> -impl<T: PartialOrd, A: Allocator> PartialOrd for Vec<T, A> {
> +impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
> +where
> +    T: PartialOrd,
> +    A1: Allocator,
> +    A2: Allocator,
> +{
>      #[inline]
> -    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
> +    fn partial_cmp(&self, other: &Vec<T, A2>) -> Option<Ordering> {
>          PartialOrd::partial_cmp(&**self, &**other)
>      }
>  }
> diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh
> index d65ab8bfeaf4..9520612dd398 100755
> --- a/scripts/min-tool-version.sh
> +++ b/scripts/min-tool-version.sh
> @@ -31,7 +31,7 @@ llvm)
>  	fi
>  	;;
>  rustc)
> -	echo 1.71.1
> +	echo 1.72.0
>  	;;
>  bindgen)
>  	echo 0.65.1
> --
> 2.42.0

Re: [PATCH 2/2] rust: upgrade to Rust 1.72.0

[Gary Guo]

On Wed, 23 Aug 2023 18:02:43 +0200
Miguel Ojeda <ojeda@kernel.org> wrote:

> This is the second upgrade to the Rust toolchain, from 1.71.1 to 1.72.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
> 
> 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 [3] for details.
> 
> # Other improvements
> 
> Previously, the compiler could incorrectly generate a `.eh_frame`
> section under `-Cpanic=abort`. We were hitting this bug in our
> old `rust` branch [4]. Gary fixed the issue in Rust 1.72.0 [5].
> 
> # Required changes
> 
> For the upgrade, the following changes are required:
> 
>   - A call to `Box::from_raw` in `rust/kernel/sync/arc.rs` now requires
>     an explicit `drop()` call. See previous patch for details.
> 
> # `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-1720-2023-08-24 [1]
> Link: https://rust-for-linux.com/rust-version-policy [2]
> Link: https://github.com/Rust-for-Linux/linux/issues/2 [3]
> Closes: https://github.com/Rust-for-Linux/linux/issues/1012 [4]
> Link: https://github.com/rust-lang/rust/pull/112403 [5]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Gary Guo <gary@garyguo.net>

> ---
>  Documentation/process/changes.rst |   2 +-
>  rust/alloc/alloc.rs               |   9 +-
>  rust/alloc/boxed.rs               |  10 +-
>  rust/alloc/lib.rs                 |  10 +-
>  rust/alloc/vec/drain_filter.rs    | 199 ------------------------------
>  rust/alloc/vec/extract_if.rs      | 115 +++++++++++++++++
>  rust/alloc/vec/mod.rs             | 106 ++++++++--------
>  scripts/min-tool-version.sh       |   2 +-
>  8 files changed, 187 insertions(+), 266 deletions(-)
>  delete mode 100644 rust/alloc/vec/drain_filter.rs
>  create mode 100644 rust/alloc/vec/extract_if.rs
> 
> diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst
> index 0bbd040f6a55..1ea95fb5af62 100644
> --- a/Documentation/process/changes.rst
> +++ b/Documentation/process/changes.rst
> @@ -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.71.1           rustc --version
> +Rust (optional)        1.72.0           rustc --version
>  bindgen (optional)     0.65.1           bindgen --version
>  GNU make               3.82             make --version
>  bash                   4.2              bash --version
> diff --git a/rust/alloc/alloc.rs b/rust/alloc/alloc.rs
> index 0b6bf5b6da43..51821feb20b1 100644
> --- a/rust/alloc/alloc.rs
> +++ b/rust/alloc/alloc.rs
> @@ -6,8 +6,10 @@
>  
>  #[cfg(not(test))]
>  use core::intrinsics;
> +#[cfg(all(bootstrap, not(test)))]
>  use core::intrinsics::{min_align_of_val, size_of_val};
>  
> +#[cfg(all(bootstrap, not(test)))]
>  use core::ptr::Unique;
>  #[cfg(not(test))]
>  use core::ptr::{self, NonNull};
> @@ -40,7 +42,6 @@
>      #[rustc_nounwind]
>      fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;
>  
> -    #[cfg(not(bootstrap))]
>      static __rust_no_alloc_shim_is_unstable: u8;
>  }
>  
> @@ -98,7 +99,6 @@ pub unsafe fn alloc(layout: Layout) -> *mut u8 {
>      unsafe {
>          // Make sure we don't accidentally allow omitting the allocator shim in
>          // stable code until it is actually stabilized.
> -        #[cfg(not(bootstrap))]
>          core::ptr::read_volatile(&__rust_no_alloc_shim_is_unstable);
>  
>          __rust_alloc(layout.size(), layout.align())
> @@ -339,14 +339,15 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
>      }
>  }
>  
> -#[cfg_attr(not(test), lang = "box_free")]
> +#[cfg(all(bootstrap, not(test)))]
> +#[lang = "box_free"]
>  #[inline]
>  // This signature has to be the same as `Box`, otherwise an ICE will happen.
>  // When an additional parameter to `Box` is added (like `A: Allocator`), this has to be added here as
>  // well.
>  // For example if `Box` is changed to  `struct Box<T: ?Sized, A: Allocator>(Unique<T>, A)`,
>  // this function has to be changed to `fn box_free<T: ?Sized, A: Allocator>(Unique<T>, A)` as well.
> -pub(crate) unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
> +unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
>      unsafe {
>          let size = size_of_val(ptr.as_ref());
>          let align = min_align_of_val(ptr.as_ref());
> diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs
> index c8173cea8317..bdab710f7737 100644
> --- a/rust/alloc/boxed.rs
> +++ b/rust/alloc/boxed.rs
> @@ -1215,8 +1215,16 @@ pub const fn into_pin(boxed: Self) -> Pin<Self>
>  
>  #[stable(feature = "rust1", since = "1.0.0")]
>  unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for Box<T, A> {
> +    #[inline]
>      fn drop(&mut self) {
> -        // FIXME: Do nothing, drop is currently performed by compiler.
> +        // the T in the Box is dropped by the compiler before the destructor is run
> +
> +        let ptr = self.0;
> +
> +        unsafe {
> +            let layout = Layout::for_value_raw(ptr.as_ptr());
> +            self.1.deallocate(From::from(ptr.cast()), layout)
> +        }
>      }
>  }
>  
> diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs
> index 85e91356ecb3..115fcb053e73 100644
> --- a/rust/alloc/lib.rs
> +++ b/rust/alloc/lib.rs
> @@ -58,6 +58,11 @@
>  //! [`Rc`]: rc
>  //! [`RefCell`]: core::cell
>  
> +// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
> +// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
> +// rustc itself never sets the feature, so this line has no affect there.
> +#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
> +//
>  #![allow(unused_attributes)]
>  #![stable(feature = "alloc", since = "1.36.0")]
>  #![doc(
> @@ -77,11 +82,6 @@
>  ))]
>  #![no_std]
>  #![needs_allocator]
> -// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
> -// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
> -// rustc itself never sets the feature, so this line has no affect there.
> -#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
> -//
>  // Lints:
>  #![deny(unsafe_op_in_unsafe_fn)]
>  #![deny(fuzzy_provenance_casts)]
> diff --git a/rust/alloc/vec/drain_filter.rs b/rust/alloc/vec/drain_filter.rs
> deleted file mode 100644
> index 09efff090e42..000000000000
> --- a/rust/alloc/vec/drain_filter.rs
> +++ /dev/null
> @@ -1,199 +0,0 @@
> -// SPDX-License-Identifier: Apache-2.0 OR MIT
> -
> -use crate::alloc::{Allocator, Global};
> -use core::mem::{ManuallyDrop, SizedTypeProperties};
> -use core::ptr;
> -use core::slice;
> -
> -use super::Vec;
> -
> -/// An iterator which uses a closure to determine if an element should be removed.
> -///
> -/// This struct is created by [`Vec::drain_filter`].
> -/// See its documentation for more.
> -///
> -/// # Example
> -///
> -/// ```
> -/// #![feature(drain_filter)]
> -///
> -/// let mut v = vec![0, 1, 2];
> -/// let iter: std::vec::DrainFilter<'_, _, _> = v.drain_filter(|x| *x % 2 == 0);
> -/// ```
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -#[derive(Debug)]
> -pub struct DrainFilter<
> -    'a,
> -    T,
> -    F,
> -    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> -> where  
> -    F: FnMut(&mut T) -> bool,
> -{
> -    pub(super) vec: &'a mut Vec<T, A>,
> -    /// The index of the item that will be inspected by the next call to `next`.
> -    pub(super) idx: usize,
> -    /// The number of items that have been drained (removed) thus far.
> -    pub(super) del: usize,
> -    /// The original length of `vec` prior to draining.
> -    pub(super) old_len: usize,
> -    /// The filter test predicate.
> -    pub(super) pred: F,
> -    /// A flag that indicates a panic has occurred in the filter test predicate.
> -    /// This is used as a hint in the drop implementation to prevent consumption
> -    /// of the remainder of the `DrainFilter`. Any unprocessed items will be
> -    /// backshifted in the `vec`, but no further items will be dropped or
> -    /// tested by the filter predicate.
> -    pub(super) panic_flag: bool,
> -}
> -
> -impl<T, F, A: Allocator> DrainFilter<'_, T, F, A>
> -where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    /// Returns a reference to the underlying allocator.
> -    #[unstable(feature = "allocator_api", issue = "32838")]
> -    #[inline]
> -    pub fn allocator(&self) -> &A {
> -        self.vec.allocator()
> -    }
> -
> -    /// Keep unyielded elements in the source `Vec`.
> -    ///
> -    /// # Examples
> -    ///
> -    /// ```
> -    /// #![feature(drain_filter)]
> -    /// #![feature(drain_keep_rest)]
> -    ///
> -    /// let mut vec = vec!['a', 'b', 'c'];
> -    /// let mut drain = vec.drain_filter(|_| true);
> -    ///
> -    /// assert_eq!(drain.next().unwrap(), 'a');
> -    ///
> -    /// // This call keeps 'b' and 'c' in the vec.
> -    /// drain.keep_rest();
> -    ///
> -    /// // If we wouldn't call `keep_rest()`,
> -    /// // `vec` would be empty.
> -    /// assert_eq!(vec, ['b', 'c']);
> -    /// ```
> -    #[unstable(feature = "drain_keep_rest", issue = "101122")]
> -    pub fn keep_rest(self) {
> -        // At this moment layout looks like this:
> -        //
> -        //  _____________________/-- old_len
> -        // /                     \
> -        // [kept] [yielded] [tail]
> -        //        \_______/ ^-- idx
> -        //                \-- del
> -        //
> -        // Normally `Drop` impl would drop [tail] (via .for_each(drop), ie still calling `pred`)
> -        //
> -        // 1. Move [tail] after [kept]
> -        // 2. Update length of the original vec to `old_len - del`
> -        //    a. In case of ZST, this is the only thing we want to do
> -        // 3. Do *not* drop self, as everything is put in a consistent state already, there is nothing to do
> -        let mut this = ManuallyDrop::new(self);
> -
> -        unsafe {
> -            // ZSTs have no identity, so we don't need to move them around.
> -            if !T::IS_ZST && this.idx < this.old_len && this.del > 0 {
> -                let ptr = this.vec.as_mut_ptr();
> -                let src = ptr.add(this.idx);
> -                let dst = src.sub(this.del);
> -                let tail_len = this.old_len - this.idx;
> -                src.copy_to(dst, tail_len);
> -            }
> -
> -            let new_len = this.old_len - this.del;
> -            this.vec.set_len(new_len);
> -        }
> -    }
> -}
> -
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A>
> -where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    type Item = T;
> -
> -    fn next(&mut self) -> Option<T> {
> -        unsafe {
> -            while self.idx < self.old_len {
> -                let i = self.idx;
> -                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
> -                self.panic_flag = true;
> -                let drained = (self.pred)(&mut v[i]);
> -                self.panic_flag = false;
> -                // Update the index *after* the predicate is called. If the index
> -                // is updated prior and the predicate panics, the element at this
> -                // index would be leaked.
> -                self.idx += 1;
> -                if drained {
> -                    self.del += 1;
> -                    return Some(ptr::read(&v[i]));
> -                } else if self.del > 0 {
> -                    let del = self.del;
> -                    let src: *const T = &v[i];
> -                    let dst: *mut T = &mut v[i - del];
> -                    ptr::copy_nonoverlapping(src, dst, 1);
> -                }
> -            }
> -            None
> -        }
> -    }
> -
> -    fn size_hint(&self) -> (usize, Option<usize>) {
> -        (0, Some(self.old_len - self.idx))
> -    }
> -}
> -
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -impl<T, F, A: Allocator> Drop for DrainFilter<'_, T, F, A>
> -where
> -    F: FnMut(&mut T) -> bool,
> -{
> -    fn drop(&mut self) {
> -        struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator>
> -        where
> -            F: FnMut(&mut T) -> bool,
> -        {
> -            drain: &'b mut DrainFilter<'a, T, F, A>,
> -        }
> -
> -        impl<'a, 'b, T, F, A: Allocator> Drop for BackshiftOnDrop<'a, 'b, T, F, A>
> -        where
> -            F: FnMut(&mut T) -> bool,
> -        {
> -            fn drop(&mut self) {
> -                unsafe {
> -                    if self.drain.idx < self.drain.old_len && self.drain.del > 0 {
> -                        // This is a pretty messed up state, and there isn't really an
> -                        // obviously right thing to do. We don't want to keep trying
> -                        // to execute `pred`, so we just backshift all the unprocessed
> -                        // elements and tell the vec that they still exist. The backshift
> -                        // is required to prevent a double-drop of the last successfully
> -                        // drained item prior to a panic in the predicate.
> -                        let ptr = self.drain.vec.as_mut_ptr();
> -                        let src = ptr.add(self.drain.idx);
> -                        let dst = src.sub(self.drain.del);
> -                        let tail_len = self.drain.old_len - self.drain.idx;
> -                        src.copy_to(dst, tail_len);
> -                    }
> -                    self.drain.vec.set_len(self.drain.old_len - self.drain.del);
> -                }
> -            }
> -        }
> -
> -        let backshift = BackshiftOnDrop { drain: self };
> -
> -        // Attempt to consume any remaining elements if the filter predicate
> -        // has not yet panicked. We'll backshift any remaining elements
> -        // whether we've already panicked or if the consumption here panics.
> -        if !backshift.drain.panic_flag {
> -            backshift.drain.for_each(drop);
> -        }
> -    }
> -}
> diff --git a/rust/alloc/vec/extract_if.rs b/rust/alloc/vec/extract_if.rs
> new file mode 100644
> index 000000000000..f314a51d4d3d
> --- /dev/null
> +++ b/rust/alloc/vec/extract_if.rs
> @@ -0,0 +1,115 @@
> +// SPDX-License-Identifier: Apache-2.0 OR MIT
> +
> +use crate::alloc::{Allocator, Global};
> +use core::ptr;
> +use core::slice;
> +
> +use super::Vec;
> +
> +/// An iterator which uses a closure to determine if an element should be removed.
> +///
> +/// This struct is created by [`Vec::extract_if`].
> +/// See its documentation for more.
> +///
> +/// # Example
> +///
> +/// ```
> +/// #![feature(extract_if)]
> +///
> +/// let mut v = vec![0, 1, 2];
> +/// let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(|x| *x % 2 == 0);
> +/// ```
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +#[derive(Debug)]
> +#[must_use = "iterators are lazy and do nothing unless consumed"]
> +pub struct ExtractIf<
> +    'a,
> +    T,
> +    F,
> +    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> +> where  
> +    F: FnMut(&mut T) -> bool,
> +{
> +    pub(super) vec: &'a mut Vec<T, A>,
> +    /// The index of the item that will be inspected by the next call to `next`.
> +    pub(super) idx: usize,
> +    /// The number of items that have been drained (removed) thus far.
> +    pub(super) del: usize,
> +    /// The original length of `vec` prior to draining.
> +    pub(super) old_len: usize,
> +    /// The filter test predicate.
> +    pub(super) pred: F,
> +}
> +
> +impl<T, F, A: Allocator> ExtractIf<'_, T, F, A>
> +where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    /// Returns a reference to the underlying allocator.
> +    #[unstable(feature = "allocator_api", issue = "32838")]
> +    #[inline]
> +    pub fn allocator(&self) -> &A {
> +        self.vec.allocator()
> +    }
> +}
> +
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
> +where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    type Item = T;
> +
> +    fn next(&mut self) -> Option<T> {
> +        unsafe {
> +            while self.idx < self.old_len {
> +                let i = self.idx;
> +                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
> +                let drained = (self.pred)(&mut v[i]);
> +                // Update the index *after* the predicate is called. If the index
> +                // is updated prior and the predicate panics, the element at this
> +                // index would be leaked.
> +                self.idx += 1;
> +                if drained {
> +                    self.del += 1;
> +                    return Some(ptr::read(&v[i]));
> +                } else if self.del > 0 {
> +                    let del = self.del;
> +                    let src: *const T = &v[i];
> +                    let dst: *mut T = &mut v[i - del];
> +                    ptr::copy_nonoverlapping(src, dst, 1);
> +                }
> +            }
> +            None
> +        }
> +    }
> +
> +    fn size_hint(&self) -> (usize, Option<usize>) {
> +        (0, Some(self.old_len - self.idx))
> +    }
> +}
> +
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
> +where
> +    F: FnMut(&mut T) -> bool,
> +{
> +    fn drop(&mut self) {
> +        unsafe {
> +            if self.idx < self.old_len && self.del > 0 {
> +                // This is a pretty messed up state, and there isn't really an
> +                // obviously right thing to do. We don't want to keep trying
> +                // to execute `pred`, so we just backshift all the unprocessed
> +                // elements and tell the vec that they still exist. The backshift
> +                // is required to prevent a double-drop of the last successfully
> +                // drained item prior to a panic in the predicate.
> +                let ptr = self.vec.as_mut_ptr();
> +                let src = ptr.add(self.idx);
> +                let dst = src.sub(self.del);
> +                let tail_len = self.old_len - self.idx;
> +                src.copy_to(dst, tail_len);
> +            }
> +            self.vec.set_len(self.old_len - self.del);
> +        }
> +    }
> +}
> diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs
> index 05c70de0227e..a4e9a5002a6d 100644
> --- a/rust/alloc/vec/mod.rs
> +++ b/rust/alloc/vec/mod.rs
> @@ -74,10 +74,10 @@
>  use crate::collections::{TryReserveError, TryReserveErrorKind};
>  use crate::raw_vec::RawVec;
>  
> -#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -pub use self::drain_filter::DrainFilter;
> +#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +pub use self::extract_if::ExtractIf;
>  
> -mod drain_filter;
> +mod extract_if;
>  
>  #[cfg(not(no_global_oom_handling))]
>  #[stable(feature = "vec_splice", since = "1.21.0")]
> @@ -618,22 +618,20 @@ pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError> {
>      /// Using memory that was allocated elsewhere:
>      ///
>      /// ```rust
> -    /// #![feature(allocator_api)]
> -    ///
> -    /// use std::alloc::{AllocError, Allocator, Global, Layout};
> +    /// use std::alloc::{alloc, Layout};
>      ///
>      /// fn main() {
>      ///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
>      ///
>      ///     let vec = unsafe {
> -    ///         let mem = match Global.allocate(layout) {
> -    ///             Ok(mem) => mem.cast::<u32>().as_ptr(),
> -    ///             Err(AllocError) => return,
> -    ///         };
> +    ///         let mem = alloc(layout).cast::<u32>();
> +    ///         if mem.is_null() {
> +    ///             return;
> +    ///         }
>      ///
>      ///         mem.write(1_000_000);
>      ///
> -    ///         Vec::from_raw_parts_in(mem, 1, 16, Global)
> +    ///         Vec::from_raw_parts(mem, 1, 16)
>      ///     };
>      ///
>      ///     assert_eq!(vec, &[1_000_000]);
> @@ -876,19 +874,22 @@ pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserv
>      /// Using memory that was allocated elsewhere:
>      ///
>      /// ```rust
> -    /// use std::alloc::{alloc, Layout};
> +    /// #![feature(allocator_api)]
> +    ///
> +    /// use std::alloc::{AllocError, Allocator, Global, Layout};
>      ///
>      /// fn main() {
>      ///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
> +    ///
>      ///     let vec = unsafe {
> -    ///         let mem = alloc(layout).cast::<u32>();
> -    ///         if mem.is_null() {
> -    ///             return;
> -    ///         }
> +    ///         let mem = match Global.allocate(layout) {
> +    ///             Ok(mem) => mem.cast::<u32>().as_ptr(),
> +    ///             Err(AllocError) => return,
> +    ///         };
>      ///
>      ///         mem.write(1_000_000);
>      ///
> -    ///         Vec::from_raw_parts(mem, 1, 16)
> +    ///         Vec::from_raw_parts_in(mem, 1, 16, Global)
>      ///     };
>      ///
>      ///     assert_eq!(vec, &[1_000_000]);
> @@ -2507,7 +2508,7 @@ pub fn resize(&mut self, new_len: usize, value: T) {
>          let len = self.len();
>  
>          if new_len > len {
> -            self.extend_with(new_len - len, ExtendElement(value))
> +            self.extend_with(new_len - len, value)
>          } else {
>              self.truncate(new_len);
>          }
> @@ -2545,7 +2546,7 @@ pub fn try_resize(&mut self, new_len: usize, value: T) -> Result<(), TryReserveE
>          let len = self.len();
>  
>          if new_len > len {
> -            self.try_extend_with(new_len - len, ExtendElement(value))
> +            self.try_extend_with(new_len - len, value)
>          } else {
>              self.truncate(new_len);
>              Ok(())
> @@ -2684,26 +2685,10 @@ pub fn into_flattened(self) -> Vec<T, A> {
>      }
>  }
>  
> -// This code generalizes `extend_with_{element,default}`.
> -trait ExtendWith<T> {
> -    fn next(&mut self) -> T;
> -    fn last(self) -> T;
> -}
> -
> -struct ExtendElement<T>(T);
> -impl<T: Clone> ExtendWith<T> for ExtendElement<T> {
> -    fn next(&mut self) -> T {
> -        self.0.clone()
> -    }
> -    fn last(self) -> T {
> -        self.0
> -    }
> -}
> -
> -impl<T, A: Allocator> Vec<T, A> {
> +impl<T: Clone, A: Allocator> Vec<T, A> {
>      #[cfg(not(no_global_oom_handling))]
> -    /// Extend the vector by `n` values, using the given generator.
> -    fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
> +    /// Extend the vector by `n` clones of value.
> +    fn extend_with(&mut self, n: usize, value: T) {
>          self.reserve(n);
>  
>          unsafe {
> @@ -2715,15 +2700,15 @@ fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
>  
>              // Write all elements except the last one
>              for _ in 1..n {
> -                ptr::write(ptr, value.next());
> +                ptr::write(ptr, value.clone());
>                  ptr = ptr.add(1);
> -                // Increment the length in every step in case next() panics
> +                // Increment the length in every step in case clone() panics
>                  local_len.increment_len(1);
>              }
>  
>              if n > 0 {
>                  // We can write the last element directly without cloning needlessly
> -                ptr::write(ptr, value.last());
> +                ptr::write(ptr, value);
>                  local_len.increment_len(1);
>              }
>  
> @@ -2731,8 +2716,8 @@ fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
>          }
>      }
>  
> -    /// Try to extend the vector by `n` values, using the given generator.
> -    fn try_extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) -> Result<(), TryReserveError> {
> +    /// Try to extend the vector by `n` clones of value.
> +    fn try_extend_with(&mut self, n: usize, value: T) -> Result<(), TryReserveError> {
>          self.try_reserve(n)?;
>  
>          unsafe {
> @@ -2744,15 +2729,15 @@ fn try_extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) -> Resul
>  
>              // Write all elements except the last one
>              for _ in 1..n {
> -                ptr::write(ptr, value.next());
> +                ptr::write(ptr, value.clone());
>                  ptr = ptr.add(1);
> -                // Increment the length in every step in case next() panics
> +                // Increment the length in every step in case clone() panics
>                  local_len.increment_len(1);
>              }
>  
>              if n > 0 {
>                  // We can write the last element directly without cloning needlessly
> -                ptr::write(ptr, value.last());
> +                ptr::write(ptr, value);
>                  local_len.increment_len(1);
>              }
>  
> @@ -3210,6 +3195,12 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
>      /// If the closure returns false, the element will remain in the vector and will not be yielded
>      /// by the iterator.
>      ///
> +    /// If the returned `ExtractIf` is not exhausted, e.g. because it is dropped without iterating
> +    /// or the iteration short-circuits, then the remaining elements will be retained.
> +    /// Use [`retain`] with a negated predicate if you do not need the returned iterator.
> +    ///
> +    /// [`retain`]: Vec::retain
> +    ///
>      /// Using this method is equivalent to the following code:
>      ///
>      /// ```
> @@ -3228,10 +3219,10 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
>      /// # assert_eq!(vec, vec![1, 4, 5]);
>      /// ```
>      ///
> -    /// But `drain_filter` is easier to use. `drain_filter` is also more efficient,
> +    /// But `extract_if` is easier to use. `extract_if` is also more efficient,
>      /// because it can backshift the elements of the array in bulk.
>      ///
> -    /// Note that `drain_filter` also lets you mutate every element in the filter closure,
> +    /// Note that `extract_if` also lets you mutate every element in the filter closure,
>      /// regardless of whether you choose to keep or remove it.
>      ///
>      /// # Examples
> @@ -3239,17 +3230,17 @@ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoI
>      /// Splitting an array into evens and odds, reusing the original allocation:
>      ///
>      /// ```
> -    /// #![feature(drain_filter)]
> +    /// #![feature(extract_if)]
>      /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
>      ///
> -    /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
> +    /// let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<Vec<_>>();
>      /// let odds = numbers;
>      ///
>      /// assert_eq!(evens, vec![2, 4, 6, 8, 14]);
>      /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
>      /// ```
> -    #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
> -    pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
> +    #[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
> +    pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A>
>      where
>          F: FnMut(&mut T) -> bool,
>      {
> @@ -3260,7 +3251,7 @@ pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
>              self.set_len(0);
>          }
>  
> -        DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false }
> +        ExtractIf { vec: self, idx: 0, del: 0, old_len, pred: filter }
>      }
>  }
>  
> @@ -3290,9 +3281,14 @@ fn extend_reserve(&mut self, additional: usize) {
>  
>  /// Implements comparison of vectors, [lexicographically](Ord#lexicographical-comparison).
>  #[stable(feature = "rust1", since = "1.0.0")]
> -impl<T: PartialOrd, A: Allocator> PartialOrd for Vec<T, A> {
> +impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
> +where
> +    T: PartialOrd,
> +    A1: Allocator,
> +    A2: Allocator,
> +{
>      #[inline]
> -    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
> +    fn partial_cmp(&self, other: &Vec<T, A2>) -> Option<Ordering> {
>          PartialOrd::partial_cmp(&**self, &**other)
>      }
>  }
> diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh
> index d65ab8bfeaf4..9520612dd398 100755
> --- a/scripts/min-tool-version.sh
> +++ b/scripts/min-tool-version.sh
> @@ -31,7 +31,7 @@ llvm)
>  	fi
>  	;;
>  rustc)
> -	echo 1.71.1
> +	echo 1.72.0
>  	;;
>  bindgen)
>  	echo 0.65.1

Re: [PATCH 2/2] rust: upgrade to Rust 1.72.0

[Martin Rodriguez Reboredo]

On 8/23/23 13:02, Miguel Ojeda wrote:
> This is the second upgrade to the Rust toolchain, from 1.71.1 to 1.72.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
> 
> 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 [3] for details.
> 
> # Other improvements
> 
> Previously, the compiler could incorrectly generate a `.eh_frame`
> section under `-Cpanic=abort`. We were hitting this bug in our
> old `rust` branch [4]. Gary fixed the issue in Rust 1.72.0 [5].
> 
> # Required changes
> 
> For the upgrade, the following changes are required:
> 
>    - A call to `Box::from_raw` in `rust/kernel/sync/arc.rs` now requires
>      an explicit `drop()` call. See previous patch for details.
> 
> # `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-1720-2023-08-24 [1]
> Link: https://rust-for-linux.com/rust-version-policy [2]
> Link: https://github.com/Rust-for-Linux/linux/issues/2 [3]
> Closes: https://github.com/Rust-for-Linux/linux/issues/1012 [4]
> Link: https://github.com/rust-lang/rust/pull/112403 [5]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
> ---
> [...]
Reviewed-by: Martin Rodriguez Reboredo <yakoyoku@gmail.com>

Re: [PATCH 2/2] rust: upgrade to Rust 1.72.0

[Alice Ryhl]

On Wed, Aug 23, 2023 at 6:03 PM Miguel Ojeda <ojeda@kernel.org> wrote:
> This is the second upgrade to the Rust toolchain, from 1.71.1 to 1.72.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").
>
> [...]
>
> Link: https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1720-2023-08-24 [1]
> Link: https://rust-for-linux.com/rust-version-policy [2]
> Link: https://github.com/Rust-for-Linux/linux/issues/2 [3]
> Closes: https://github.com/Rust-for-Linux/linux/issues/1012 [4]
> Link: https://github.com/rust-lang/rust/pull/112403 [5]
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Alice Ryhl <aliceryhl@google.com>

Re: [PATCH 0/2] Rust 1.72.0 upgrade

[Miguel Ojeda]

On Wed, Aug 23, 2023 at 6:02 PM Miguel Ojeda <ojeda@kernel.org> wrote:
>
> This is the third upgrade to the Rust toolchain since the initial Rust
> merge, from 1.71.1 to 1.72.0 (i.e. the latest, to be released tomorrow).
>
> Please see the main patch message for a long explanation of the upgrade,
> the policy for future upgrades and some indications on how to easily
> review this.
>
> The series is based on `rust-next`.

Applied to `rust-next`, using 1.72.1 instead of .0 (no changes
otherwise, i.e. in `alloc`) and reworded to mention that we were
hitting the bug with debug assertions enabled.

Thanks everyone!

Cheers,
Miguel