diff options
Diffstat (limited to 'pkgs/os-specific')
22 files changed, 938 insertions, 107 deletions
diff --git a/pkgs/os-specific/bsd/lib/install-wrapper.sh b/pkgs/os-specific/bsd/lib/install-wrapper.sh index 91a7a2679f209..97a2aaab22c0e 100644 --- a/pkgs/os-specific/bsd/lib/install-wrapper.sh +++ b/pkgs/os-specific/bsd/lib/install-wrapper.sh @@ -14,7 +14,6 @@ while (( $# )); do case $1 in -C) ;; -o | -g) shift ;; - -s) ;; -m | -l) # handle next arg so not counted as path arg args+=("$1" "$2") diff --git a/pkgs/os-specific/linux/anbox/default.nix b/pkgs/os-specific/linux/anbox/default.nix index 3a5649d9f2882..1cb614fa220bb 100644 --- a/pkgs/os-specific/linux/anbox/default.nix +++ b/pkgs/os-specific/linux/anbox/default.nix @@ -58,6 +58,7 @@ stdenv.mkDerivation rec { cmake pkg-config makeWrapper + protobufc ]; buildInputs = [ @@ -74,7 +75,7 @@ stdenv.mkDerivation rec { lxc mesa properties-cpp - protobuf protobufc + protobuf python3 SDL2 SDL2_image systemd diff --git a/pkgs/os-specific/linux/busybox/default.nix b/pkgs/os-specific/linux/busybox/default.nix index 33fa7663f46dd..4a291cc03b8f6 100644 --- a/pkgs/os-specific/linux/busybox/default.nix +++ b/pkgs/os-specific/linux/busybox/default.nix @@ -121,6 +121,10 @@ stdenv.mkDerivation rec { # Bump from 4KB, much faster I/O CONFIG_FEATURE_COPYBUF_KB 64 + # Doesn't build with current kernel headers. + # https://bugs.busybox.net/show_bug.cgi?id=15934 + CONFIG_TC n + # Set the path for the udhcpc script CONFIG_UDHCPC_DEFAULT_SCRIPT "${outDispatchPath}" diff --git a/pkgs/os-specific/linux/ell/default.nix b/pkgs/os-specific/linux/ell/default.nix index 9c16a341a478f..1a5e119ef4737 100644 --- a/pkgs/os-specific/linux/ell/default.nix +++ b/pkgs/os-specific/linux/ell/default.nix @@ -9,14 +9,14 @@ stdenv.mkDerivation rec { pname = "ell"; - version = "0.64"; + version = "0.65"; outputs = [ "out" "dev" ]; src = fetchgit { url = "https://git.kernel.org/pub/scm/libs/ell/ell.git"; rev = version; - hash = "sha256-LONfgFgPg8KCDwtw//WTOYQT9RpnIskdHAWcgafOhcg="; + hash = "sha256-q0C9KfWHxdmrG7xcbb8zpFL4ro+BJb7BL2tyKdFIhew="; }; nativeBuildInputs = [ diff --git a/pkgs/os-specific/linux/kernel-headers/default.nix b/pkgs/os-specific/linux/kernel-headers/default.nix index fc2f8ddbd1434..bf3bf4950a259 100644 --- a/pkgs/os-specific/linux/kernel-headers/default.nix +++ b/pkgs/os-specific/linux/kernel-headers/default.nix @@ -111,12 +111,12 @@ let in { inherit makeLinuxHeaders; - linuxHeaders = let version = "6.7"; in + linuxHeaders = let version = "6.9"; in makeLinuxHeaders { inherit version; src = fetchurl { url = "mirror://kernel/linux/kernel/v${lib.versions.major version}.x/linux-${version}.tar.xz"; - hash = "sha256-7zEUSiV20IDYwxaY6D7J9mv5fGd/oqrw1bu58zRbEGk="; + hash = "sha256-JPoB+5icej4oRT8Rd5kWhxN2bhGcU4HawwEV8Y8mgUk="; }; patches = [ ./no-relocs.patch # for building x86 kernel headers on non-ELF platforms diff --git a/pkgs/os-specific/linux/kernel/generic.nix b/pkgs/os-specific/linux/kernel/generic.nix index 37c138402d006..081cfcaa8b60f 100644 --- a/pkgs/os-specific/linux/kernel/generic.nix +++ b/pkgs/os-specific/linux/kernel/generic.nix @@ -97,7 +97,7 @@ let # For further context, see https://github.com/NixOS/nixpkgs/pull/143113#issuecomment-953319957 basicArgs = builtins.removeAttrs args - (lib.filter (x: ! (builtins.elem x [ "version" "src" ])) (lib.attrNames args)); + (lib.filter (x: ! (builtins.elem x [ "version" "pname" "src" ])) (lib.attrNames args)); # Combine the `features' attribute sets of all the kernel patches. kernelFeatures = lib.foldr (x: y: (x.features or {}) // y) ({ diff --git a/pkgs/os-specific/linux/kernel/linux-libre.nix b/pkgs/os-specific/linux/kernel/linux-libre.nix index 4bb2ebda3d028..9a03c39ec5691 100644 --- a/pkgs/os-specific/linux/kernel/linux-libre.nix +++ b/pkgs/os-specific/linux/kernel/linux-libre.nix @@ -23,6 +23,7 @@ in linux.override { argsOverride = { modDirVersion = "${linux.modDirVersion}-${versionPrefix}"; isLibre = true; + pname = "linux-libre"; src = stdenv.mkDerivation { name = "${linux.name}-libre-src"; diff --git a/pkgs/os-specific/linux/kernel/linux-rpi.nix b/pkgs/os-specific/linux/kernel/linux-rpi.nix index f1449998984be..e0ce6549235d6 100644 --- a/pkgs/os-specific/linux/kernel/linux-rpi.nix +++ b/pkgs/os-specific/linux/kernel/linux-rpi.nix @@ -8,6 +8,7 @@ in lib.overrideDerivation (buildLinux (args // { version = "${modDirVersion}-${tag}"; inherit modDirVersion; + pname = "linux-rpi"; src = fetchFromGitHub { owner = "raspberrypi"; diff --git a/pkgs/os-specific/linux/kernel/linux-rt-5.10.nix b/pkgs/os-specific/linux/kernel/linux-rt-5.10.nix index d2cc98b8159dc..2792aacce3427 100644 --- a/pkgs/os-specific/linux/kernel/linux-rt-5.10.nix +++ b/pkgs/os-specific/linux/kernel/linux-rt-5.10.nix @@ -11,6 +11,7 @@ let kversion = builtins.elemAt (lib.splitString "-" version) 0; in buildLinux (args // { inherit version; + pname = "linux-rt"; # modDirVersion needs a patch number, change X.Y-rtZ to X.Y.0-rtZ. modDirVersion = lib.versions.pad 3 version; diff --git a/pkgs/os-specific/linux/kernel/linux-rt-5.15.nix b/pkgs/os-specific/linux/kernel/linux-rt-5.15.nix index 5e43eca364d42..47634d116e9ac 100644 --- a/pkgs/os-specific/linux/kernel/linux-rt-5.15.nix +++ b/pkgs/os-specific/linux/kernel/linux-rt-5.15.nix @@ -11,6 +11,7 @@ let kversion = builtins.elemAt (lib.splitString "-" version) 0; in buildLinux (args // { inherit version; + pname = "linux-rt"; # modDirVersion needs a patch number, change X.Y-rtZ to X.Y.0-rtZ. modDirVersion = if (builtins.match "[^.]*[.][^.]*-.*" version) == null then version diff --git a/pkgs/os-specific/linux/kernel/linux-rt-5.4.nix b/pkgs/os-specific/linux/kernel/linux-rt-5.4.nix index 463385036292e..2fc18c76e5706 100644 --- a/pkgs/os-specific/linux/kernel/linux-rt-5.4.nix +++ b/pkgs/os-specific/linux/kernel/linux-rt-5.4.nix @@ -11,6 +11,7 @@ let kversion = builtins.elemAt (lib.splitString "-" version) 0; in buildLinux (args // { inherit version; + pname = "linux-rt"; src = fetchurl { url = "mirror://kernel/linux/kernel/v5.x/linux-${kversion}.tar.xz"; diff --git a/pkgs/os-specific/linux/kernel/linux-rt-6.1.nix b/pkgs/os-specific/linux/kernel/linux-rt-6.1.nix index f7f21a71263bd..0427f9c15986d 100644 --- a/pkgs/os-specific/linux/kernel/linux-rt-6.1.nix +++ b/pkgs/os-specific/linux/kernel/linux-rt-6.1.nix @@ -11,6 +11,7 @@ let kversion = builtins.elemAt (lib.splitString "-" version) 0; in buildLinux (args // { inherit version; + pname = "linux-rt"; # modDirVersion needs a patch number, change X.Y-rtZ to X.Y.0-rtZ. modDirVersion = if (builtins.match "[^.]*[.][^.]*-.*" version) == null then version diff --git a/pkgs/os-specific/linux/kernel/linux-rt-6.6.nix b/pkgs/os-specific/linux/kernel/linux-rt-6.6.nix index 2f035b259b602..57c268fe397e0 100644 --- a/pkgs/os-specific/linux/kernel/linux-rt-6.6.nix +++ b/pkgs/os-specific/linux/kernel/linux-rt-6.6.nix @@ -11,6 +11,7 @@ let kversion = builtins.elemAt (lib.splitString "-" version) 0; in buildLinux (args // { inherit version; + pname = "linux-rt"; # modDirVersion needs a patch number, change X.Y-rtZ to X.Y.0-rtZ. modDirVersion = if (builtins.match "[^.]*[.][^.]*-.*" version) == null then version diff --git a/pkgs/os-specific/linux/kernel/manual-config.nix b/pkgs/os-specific/linux/kernel/manual-config.nix index 0c176d3e12d93..cb75f013b6241 100644 --- a/pkgs/os-specific/linux/kernel/manual-config.nix +++ b/pkgs/os-specific/linux/kernel/manual-config.nix @@ -20,6 +20,8 @@ let in lib.makeOverridable ({ # The kernel version version, + # The kernel pname (should be set for variants) + pname ? "linux", # Position of the Linux build expression pos ? null, # Additional kernel make flags @@ -408,8 +410,7 @@ assert lib.versionOlder version "5.8" -> libelf != null; assert lib.versionAtLeast version "5.8" -> elfutils != null; stdenv.mkDerivation ((drvAttrs config stdenv.hostPlatform.linux-kernel kernelPatches configfile) // { - pname = "linux"; - inherit version; + inherit pname version; enableParallelBuilding = true; diff --git a/pkgs/os-specific/linux/kernel/patches.nix b/pkgs/os-specific/linux/kernel/patches.nix index 20100774395e1..c1715a91e5fbc 100644 --- a/pkgs/os-specific/linux/kernel/patches.nix +++ b/pkgs/os-specific/linux/kernel/patches.nix @@ -82,15 +82,21 @@ rust_1_77-6_8 = { name = "rust-1.77.patch"; - patch = fetchurl { - name = "rust-1.77.patch"; - url = "https://lore.kernel.org/rust-for-linux/20240217002717.57507-1-ojeda@kernel.org/raw"; - hash = "sha256-0KW9nHpJeMSDssCPXWZbrN8kxq5bA434t+XuPfwslUc="; - }; + patch = ./rust-1.77-6.8.patch; }; rust_1_77-6_9 = { name = "rust-1.77.patch"; patch = ./rust-1.77.patch; }; + + rust_1_78 = { + name = "rust-1.78.patch"; + patch = fetchpatch { + name = "rust-1.78.patch"; + url = "https://lore.kernel.org/rust-for-linux/20240401212303.537355-4-ojeda@kernel.org/raw"; + excludes = [ "Documentation/process/changes.rst" ]; # Conflicts on 6.8. + hash = "sha256-EZ+Qa9z1AtAv08e72M7BEsCZi9UK572gmW+AR62a8EM="; + }; + }; } diff --git a/pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch b/pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch new file mode 100644 index 0000000000000..4b25d3e60e39d --- /dev/null +++ b/pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch @@ -0,0 +1,799 @@ +From 82a754271336c7736fb0350692be85fecb30e38e Mon Sep 17 00:00:00 2001 +From: Miguel Ojeda <ojeda@kernel.org> +Date: Sat, 17 Feb 2024 01:27:17 +0100 +Subject: [PATCH] rust: upgrade to Rust 1.77.1 + +This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.1 +(i.e. the latest) [1]. + +See the upgrade policy [2] and the comments on the first upgrade in +commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2"). + +# Unstable features + +The `offset_of` feature (single-field `offset_of!`) that we were using +got stabilized in Rust 1.77.0 [3]. + +Therefore, now the only unstable features allowed to be used outside the +`kernel` crate is `new_uninit`, though other code to be upstreamed may +increase the list. + +Please see [4] for details. + +# Required changes + +Rust 1.77.0 merged the `unused_tuple_struct_fields` lint into `dead_code`, +thus upgrading it from `allow` to `warn` [5]. In turn, this made `rustc` +complain about the `ThisModule`'s pointer field being never read, but +the previous patch adds the `as_ptr` method to it, needed by Binder [6], +so that we do not need to locally `allow` it. + +# Other changes + +Rust 1.77.0 introduces the `--check-cfg` feature [7], for which there +is a Call for Testing going on [8]. We were requested to test it and +we found it useful [9] -- we will likely enable it in the future. + +# `alloc` upgrade and reviewing + +The vast majority of changes are due to our `alloc` fork being upgraded +at once. + +There are two kinds of changes to be aware of: the ones coming from +upstream, which we should follow as closely as possible, and the updates +needed in our added fallible APIs to keep them matching the newer +infallible APIs coming from upstream. + +Instead of taking a look at the diff of this patch, an alternative +approach is reviewing a diff of the changes between upstream `alloc` and +the kernel's. This allows to easily inspect the kernel additions only, +especially to check if the fallible methods we already have still match +the infallible ones in the new version coming from upstream. + +Another approach is reviewing the changes introduced in the additions in +the kernel fork between the two versions. This is useful to spot +potentially unintended changes to our additions. + +To apply these approaches, one may follow steps similar to the following +to generate a pair of patches that show the differences between upstream +Rust and the kernel (for the subset of `alloc` we use) before and after +applying this patch: + + # Get the difference with respect to the old version. + git -C rust checkout $(linux/scripts/min-tool-version.sh rustc) + git -C linux ls-tree -r --name-only HEAD -- rust/alloc | + cut -d/ -f3- | + grep -Fv README.md | + xargs -IPATH cp rust/library/alloc/src/PATH linux/rust/alloc/PATH + git -C linux diff --patch-with-stat --summary -R > old.patch + git -C linux restore rust/alloc + + # Apply this patch. + git -C linux am rust-upgrade.patch + + # Get the difference with respect to the new version. + git -C rust checkout $(linux/scripts/min-tool-version.sh rustc) + git -C linux ls-tree -r --name-only HEAD -- rust/alloc | + cut -d/ -f3- | + grep -Fv README.md | + xargs -IPATH cp rust/library/alloc/src/PATH linux/rust/alloc/PATH + git -C linux diff --patch-with-stat --summary -R > new.patch + git -C linux restore rust/alloc + +Now one may check the `new.patch` to take a look at the additions (first +approach) or at the difference between those two patches (second +approach). For the latter, a side-by-side tool is recommended. + +Link: https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1770-2024-03-21 [1] +Link: https://rust-for-linux.com/rust-version-policy [2] +Link: https://github.com/rust-lang/rust/pull/118799 [3] +Link: https://github.com/Rust-for-Linux/linux/issues/2 [4] +Link: https://github.com/rust-lang/rust/pull/118297 [5] +Link: https://lore.kernel.org/rust-for-linux/20231101-rust-binder-v1-2-08ba9197f637@google.com/#Z31rust:kernel:lib.rs [6] +Link: https://doc.rust-lang.org/nightly/unstable-book/compiler-flags/check-cfg.html [7] +Link: https://github.com/rust-lang/rfcs/pull/3013#issuecomment-1936648479 [8] +Link: https://github.com/rust-lang/rust/issues/82450#issuecomment-1947462977 [9] +Reviewed-by: Alice Ryhl <aliceryhl@google.com> +Tested-by: Boqun Feng <boqun.feng@gmail.com> +Link: https://lore.kernel.org/r/20240217002717.57507-1-ojeda@kernel.org +[ Upgraded to 1.77.1. Removed `allow(dead_code)` thanks to the previous + patch. Reworded accordingly. No changes to `alloc` during the beta. ] +Signed-off-by: Miguel Ojeda <ojeda@kernel.org> +Signed-off-by: Alyssa Ross <hi@alyssa.is> + +# Conflicts: +# Documentation/process/changes.rst +# rust/kernel/lib.rs +--- + Documentation/process/changes.rst | 2 +- + rust/alloc/alloc.rs | 6 +- + rust/alloc/boxed.rs | 4 +- + rust/alloc/lib.rs | 7 +- + rust/alloc/raw_vec.rs | 13 ++-- + rust/alloc/slice.rs | 4 +- + rust/alloc/vec/into_iter.rs | 104 +++++++++++++++++++----------- + rust/alloc/vec/mod.rs | 101 ++++++++++++++++++++--------- + rust/kernel/lib.rs | 1 - + scripts/Makefile.build | 2 +- + scripts/min-tool-version.sh | 2 +- + 11 files changed, 158 insertions(+), 88 deletions(-) + +diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst +index c78ecc1e176f..641d67363b92 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.76.0 rustc --version ++Rust (optional) 1.77.1 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 abb791cc2371..b1204f87227b 100644 +--- a/rust/alloc/alloc.rs ++++ b/rust/alloc/alloc.rs +@@ -5,7 +5,7 @@ + #![stable(feature = "alloc_module", since = "1.28.0")] + + #[cfg(not(test))] +-use core::intrinsics; ++use core::hint; + + #[cfg(not(test))] + use core::ptr::{self, NonNull}; +@@ -210,7 +210,7 @@ unsafe fn grow_impl( + let new_size = new_layout.size(); + + // `realloc` probably checks for `new_size >= old_layout.size()` or something similar. +- intrinsics::assume(new_size >= old_layout.size()); ++ hint::assert_unchecked(new_size >= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; +@@ -301,7 +301,7 @@ unsafe fn shrink( + // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller + new_size if old_layout.align() == new_layout.align() => unsafe { + // `realloc` probably checks for `new_size <= old_layout.size()` or something similar. +- intrinsics::assume(new_size <= old_layout.size()); ++ hint::assert_unchecked(new_size <= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; +diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs +index c93a22a5c97f..5fc39dfeb8e7 100644 +--- a/rust/alloc/boxed.rs ++++ b/rust/alloc/boxed.rs +@@ -26,6 +26,7 @@ + //! Creating a recursive data structure: + //! + //! ``` ++//! ##[allow(dead_code)] + //! #[derive(Debug)] + //! enum List<T> { + //! Cons(T, Box<List<T>>), +@@ -194,8 +195,7 @@ + #[fundamental] + #[stable(feature = "rust1", since = "1.0.0")] + // The declaration of the `Box` struct must be kept in sync with the +-// `alloc::alloc::box_free` function or ICEs will happen. See the comment +-// on `box_free` for more details. ++// compiler or ICEs will happen. + pub struct Box< + T: ?Sized, + #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, +diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs +index 36f79c075593..39afd55ec074 100644 +--- a/rust/alloc/lib.rs ++++ b/rust/alloc/lib.rs +@@ -105,7 +105,6 @@ + #![feature(allocator_api)] + #![feature(array_chunks)] + #![feature(array_into_iter_constructors)] +-#![feature(array_methods)] + #![feature(array_windows)] + #![feature(ascii_char)] + #![feature(assert_matches)] +@@ -122,7 +121,6 @@ + #![feature(const_size_of_val)] + #![feature(const_waker)] + #![feature(core_intrinsics)] +-#![feature(core_panic)] + #![feature(deprecated_suggestion)] + #![feature(dispatch_from_dyn)] + #![feature(error_generic_member_access)] +@@ -132,6 +130,7 @@ + #![feature(fmt_internals)] + #![feature(fn_traits)] + #![feature(hasher_prefixfree_extras)] ++#![feature(hint_assert_unchecked)] + #![feature(inline_const)] + #![feature(inplace_iteration)] + #![feature(iter_advance_by)] +@@ -141,6 +140,8 @@ + #![feature(maybe_uninit_slice)] + #![feature(maybe_uninit_uninit_array)] + #![feature(maybe_uninit_uninit_array_transpose)] ++#![feature(non_null_convenience)] ++#![feature(panic_internals)] + #![feature(pattern)] + #![feature(ptr_internals)] + #![feature(ptr_metadata)] +@@ -149,7 +150,6 @@ + #![feature(set_ptr_value)] + #![feature(sized_type_properties)] + #![feature(slice_from_ptr_range)] +-#![feature(slice_group_by)] + #![feature(slice_ptr_get)] + #![feature(slice_ptr_len)] + #![feature(slice_range)] +@@ -182,6 +182,7 @@ + #![feature(const_ptr_write)] + #![feature(const_trait_impl)] + #![feature(const_try)] ++#![feature(decl_macro)] + #![feature(dropck_eyepatch)] + #![feature(exclusive_range_pattern)] + #![feature(fundamental)] +diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs +index 98b6abf30af6..1839d1c8ee7a 100644 +--- a/rust/alloc/raw_vec.rs ++++ b/rust/alloc/raw_vec.rs +@@ -4,7 +4,7 @@ + + use core::alloc::LayoutError; + use core::cmp; +-use core::intrinsics; ++use core::hint; + use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; + use core::ptr::{self, NonNull, Unique}; + use core::slice; +@@ -317,7 +317,7 @@ fn current_memory(&self) -> Option<(NonNull<u8>, Layout)> { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Aborts + /// +@@ -358,7 +358,7 @@ pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryRe + } + unsafe { + // Inform the optimizer that the reservation has succeeded or wasn't needed +- core::intrinsics::assume(!self.needs_to_grow(len, additional)); ++ hint::assert_unchecked(!self.needs_to_grow(len, additional)); + } + Ok(()) + } +@@ -381,7 +381,7 @@ pub fn try_reserve_for_push(&mut self, len: usize) -> Result<(), TryReserveError + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Aborts + /// +@@ -402,7 +402,7 @@ pub fn try_reserve_exact( + } + unsafe { + // Inform the optimizer that the reservation has succeeded or wasn't needed +- core::intrinsics::assume(!self.needs_to_grow(len, additional)); ++ hint::assert_unchecked(!self.needs_to_grow(len, additional)); + } + Ok(()) + } +@@ -553,7 +553,7 @@ fn finish_grow<A>( + debug_assert_eq!(old_layout.align(), new_layout.align()); + unsafe { + // The allocator checks for alignment equality +- intrinsics::assume(old_layout.align() == new_layout.align()); ++ hint::assert_unchecked(old_layout.align() == new_layout.align()); + alloc.grow(ptr, old_layout, new_layout) + } + } else { +@@ -591,7 +591,6 @@ fn handle_reserve(result: Result<(), TryReserveError>) { + // `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add + // an extra guard for this in case we're running on a platform which can use + // all 4GB in user-space, e.g., PAE or x32. +- + #[inline] + fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { + if usize::BITS < 64 && alloc_size > isize::MAX as usize { +diff --git a/rust/alloc/slice.rs b/rust/alloc/slice.rs +index 1181836da5f4..a36b072c9519 100644 +--- a/rust/alloc/slice.rs ++++ b/rust/alloc/slice.rs +@@ -53,14 +53,14 @@ + pub use core::slice::{from_mut_ptr_range, from_ptr_range}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{from_raw_parts, from_raw_parts_mut}; ++#[stable(feature = "slice_group_by", since = "1.77.0")] ++pub use core::slice::{ChunkBy, ChunkByMut}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{Chunks, Windows}; + #[stable(feature = "chunks_exact", since = "1.31.0")] + pub use core::slice::{ChunksExact, ChunksExactMut}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{ChunksMut, Split, SplitMut}; +-#[unstable(feature = "slice_group_by", issue = "80552")] +-pub use core::slice::{GroupBy, GroupByMut}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{Iter, IterMut}; + #[stable(feature = "rchunks", since = "1.31.0")] +diff --git a/rust/alloc/vec/into_iter.rs b/rust/alloc/vec/into_iter.rs +index 136bfe94af6c..0f11744c44b3 100644 +--- a/rust/alloc/vec/into_iter.rs ++++ b/rust/alloc/vec/into_iter.rs +@@ -20,6 +20,17 @@ + use core::ptr::{self, NonNull}; + use core::slice::{self}; + ++macro non_null { ++ (mut $place:expr, $t:ident) => {{ ++ #![allow(unused_unsafe)] // we're sometimes used within an unsafe block ++ unsafe { &mut *(ptr::addr_of_mut!($place) as *mut NonNull<$t>) } ++ }}, ++ ($place:expr, $t:ident) => {{ ++ #![allow(unused_unsafe)] // we're sometimes used within an unsafe block ++ unsafe { *(ptr::addr_of!($place) as *const NonNull<$t>) } ++ }}, ++} ++ + /// An iterator that moves out of a vector. + /// + /// This `struct` is created by the `into_iter` method on [`Vec`](super::Vec) +@@ -43,10 +54,12 @@ pub struct IntoIter< + // the drop impl reconstructs a RawVec from buf, cap and alloc + // to avoid dropping the allocator twice we need to wrap it into ManuallyDrop + pub(super) alloc: ManuallyDrop<A>, +- pub(super) ptr: *const T, +- pub(super) end: *const T, // If T is a ZST, this is actually ptr+len. This encoding is picked so that +- // ptr == end is a quick test for the Iterator being empty, that works +- // for both ZST and non-ZST. ++ pub(super) ptr: NonNull<T>, ++ /// If T is a ZST, this is actually ptr+len. This encoding is picked so that ++ /// ptr == end is a quick test for the Iterator being empty, that works ++ /// for both ZST and non-ZST. ++ /// For non-ZSTs the pointer is treated as `NonNull<T>` ++ pub(super) end: *const T, + } + + #[stable(feature = "vec_intoiter_debug", since = "1.13.0")] +@@ -70,7 +83,7 @@ impl<T, A: Allocator> IntoIter<T, A> { + /// ``` + #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")] + pub fn as_slice(&self) -> &[T] { +- unsafe { slice::from_raw_parts(self.ptr, self.len()) } ++ unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len()) } + } + + /// Returns the remaining items of this iterator as a mutable slice. +@@ -99,7 +112,7 @@ pub fn allocator(&self) -> &A { + } + + fn as_raw_mut_slice(&mut self) -> *mut [T] { +- ptr::slice_from_raw_parts_mut(self.ptr as *mut T, self.len()) ++ ptr::slice_from_raw_parts_mut(self.ptr.as_ptr(), self.len()) + } + + /// Drops remaining elements and relinquishes the backing allocation. +@@ -126,7 +139,7 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { + // this creates less assembly + self.cap = 0; + self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) }; +- self.ptr = self.buf.as_ptr(); ++ self.ptr = self.buf; + self.end = self.buf.as_ptr(); + + // Dropping the remaining elements can panic, so this needs to be +@@ -138,9 +151,9 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { + + /// Forgets to Drop the remaining elements while still allowing the backing allocation to be freed. + pub(crate) fn forget_remaining_elements(&mut self) { +- // For th ZST case, it is crucial that we mutate `end` here, not `ptr`. ++ // For the ZST case, it is crucial that we mutate `end` here, not `ptr`. + // `ptr` must stay aligned, while `end` may be unaligned. +- self.end = self.ptr; ++ self.end = self.ptr.as_ptr(); + } + + #[cfg(not(no_global_oom_handling))] +@@ -162,7 +175,7 @@ pub(crate) fn into_vecdeque(self) -> VecDeque<T, A> { + // say that they're all at the beginning of the "allocation". + 0..this.len() + } else { +- this.ptr.sub_ptr(buf)..this.end.sub_ptr(buf) ++ this.ptr.sub_ptr(this.buf)..this.end.sub_ptr(buf) + }; + let cap = this.cap; + let alloc = ManuallyDrop::take(&mut this.alloc); +@@ -189,29 +202,35 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { + + #[inline] + fn next(&mut self) -> Option<T> { +- if self.ptr == self.end { +- None +- } else if T::IS_ZST { +- // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by +- // reducing the `end`. +- self.end = self.end.wrapping_byte_sub(1); ++ if T::IS_ZST { ++ if self.ptr.as_ptr() == self.end as *mut _ { ++ None ++ } else { ++ // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by ++ // reducing the `end`. ++ self.end = self.end.wrapping_byte_sub(1); + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) ++ // Make up a value of this ZST. ++ Some(unsafe { mem::zeroed() }) ++ } + } else { +- let old = self.ptr; +- self.ptr = unsafe { self.ptr.add(1) }; ++ if self.ptr == non_null!(self.end, T) { ++ None ++ } else { ++ let old = self.ptr; ++ self.ptr = unsafe { old.add(1) }; + +- Some(unsafe { ptr::read(old) }) ++ Some(unsafe { ptr::read(old.as_ptr()) }) ++ } + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option<usize>) { + let exact = if T::IS_ZST { +- self.end.addr().wrapping_sub(self.ptr.addr()) ++ self.end.addr().wrapping_sub(self.ptr.as_ptr().addr()) + } else { +- unsafe { self.end.sub_ptr(self.ptr) } ++ unsafe { non_null!(self.end, T).sub_ptr(self.ptr) } + }; + (exact, Some(exact)) + } +@@ -219,7 +238,7 @@ fn size_hint(&self) -> (usize, Option<usize>) { + #[inline] + fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { + let step_size = self.len().min(n); +- let to_drop = ptr::slice_from_raw_parts_mut(self.ptr as *mut T, step_size); ++ let to_drop = ptr::slice_from_raw_parts_mut(self.ptr.as_ptr(), step_size); + if T::IS_ZST { + // See `next` for why we sub `end` here. + self.end = self.end.wrapping_byte_sub(step_size); +@@ -261,7 +280,7 @@ fn count(self) -> usize { + // Safety: `len` indicates that this many elements are available and we just checked that + // it fits into the array. + unsafe { +- ptr::copy_nonoverlapping(self.ptr, raw_ary.as_mut_ptr() as *mut T, len); ++ ptr::copy_nonoverlapping(self.ptr.as_ptr(), raw_ary.as_mut_ptr() as *mut T, len); + self.forget_remaining_elements(); + return Err(array::IntoIter::new_unchecked(raw_ary, 0..len)); + } +@@ -270,7 +289,7 @@ fn count(self) -> usize { + // Safety: `len` is larger than the array size. Copy a fixed amount here to fully initialize + // the array. + return unsafe { +- ptr::copy_nonoverlapping(self.ptr, raw_ary.as_mut_ptr() as *mut T, N); ++ ptr::copy_nonoverlapping(self.ptr.as_ptr(), raw_ary.as_mut_ptr() as *mut T, N); + self.ptr = self.ptr.add(N); + Ok(raw_ary.transpose().assume_init()) + }; +@@ -288,7 +307,7 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item + // Also note the implementation of `Self: TrustedRandomAccess` requires + // that `T: Copy` so reading elements from the buffer doesn't invalidate + // them for `Drop`. +- unsafe { if T::IS_ZST { mem::zeroed() } else { ptr::read(self.ptr.add(i)) } } ++ unsafe { if T::IS_ZST { mem::zeroed() } else { self.ptr.add(i).read() } } + } + } + +@@ -296,18 +315,25 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item + impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { + #[inline] + fn next_back(&mut self) -> Option<T> { +- if self.end == self.ptr { +- None +- } else if T::IS_ZST { +- // See above for why 'ptr.offset' isn't used +- self.end = self.end.wrapping_byte_sub(1); ++ if T::IS_ZST { ++ if self.end as *mut _ == self.ptr.as_ptr() { ++ None ++ } else { ++ // See above for why 'ptr.offset' isn't used ++ self.end = self.end.wrapping_byte_sub(1); + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) ++ // Make up a value of this ZST. ++ Some(unsafe { mem::zeroed() }) ++ } + } else { +- self.end = unsafe { self.end.sub(1) }; ++ if non_null!(self.end, T) == self.ptr { ++ None ++ } else { ++ let new_end = unsafe { non_null!(self.end, T).sub(1) }; ++ *non_null!(mut self.end, T) = new_end; + +- Some(unsafe { ptr::read(self.end) }) ++ Some(unsafe { ptr::read(new_end.as_ptr()) }) ++ } + } + } + +@@ -333,7 +359,11 @@ fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { + #[stable(feature = "rust1", since = "1.0.0")] + impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> { + fn is_empty(&self) -> bool { +- self.ptr == self.end ++ if T::IS_ZST { ++ self.ptr.as_ptr() == self.end as *mut _ ++ } else { ++ self.ptr == non_null!(self.end, T) ++ } + } + } + +diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs +index 220fb9d6f45b..0be27fff4554 100644 +--- a/rust/alloc/vec/mod.rs ++++ b/rust/alloc/vec/mod.rs +@@ -360,7 +360,7 @@ + /// + /// `vec![x; n]`, `vec![a, b, c, d]`, and + /// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec` +-/// with exactly the requested capacity. If <code>[len] == [capacity]</code>, ++/// with at least the requested capacity. If <code>[len] == [capacity]</code>, + /// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to + /// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements. + /// +@@ -447,7 +447,7 @@ pub const fn new() -> Self { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -690,7 +690,7 @@ pub const fn new_in(alloc: A) -> Self { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -1013,7 +1013,7 @@ pub fn capacity(&self) -> usize { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -1043,7 +1043,7 @@ pub fn reserve(&mut self, additional: usize) { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -1140,8 +1140,11 @@ pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveE + + /// Shrinks the capacity of the vector as much as possible. + /// +- /// It will drop down as close as possible to the length but the allocator +- /// may still inform the vector that there is space for a few more elements. ++ /// The behavior of this method depends on the allocator, which may either shrink the vector ++ /// in-place or reallocate. The resulting vector might still have some excess capacity, just as ++ /// is the case for [`with_capacity`]. See [`Allocator::shrink`] for more details. ++ /// ++ /// [`with_capacity`]: Vec::with_capacity + /// + /// # Examples + /// +@@ -1191,10 +1194,10 @@ pub fn shrink_to(&mut self, min_capacity: usize) { + + /// Converts the vector into [`Box<[T]>`][owned slice]. + /// +- /// If the vector has excess capacity, its items will be moved into a +- /// newly-allocated buffer with exactly the right capacity. ++ /// Before doing the conversion, this method discards excess capacity like [`shrink_to_fit`]. + /// + /// [owned slice]: Box ++ /// [`shrink_to_fit`]: Vec::shrink_to_fit + /// + /// # Examples + /// +@@ -2017,7 +2020,7 @@ fn drop(&mut self) { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -2133,7 +2136,7 @@ pub fn pop(&mut self) -> Option<T> { + } else { + unsafe { + self.len -= 1; +- core::intrinsics::assume(self.len < self.capacity()); ++ core::hint::assert_unchecked(self.len < self.capacity()); + Some(ptr::read(self.as_ptr().add(self.len()))) + } + } +@@ -2143,7 +2146,7 @@ pub fn pop(&mut self) -> Option<T> { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -2315,6 +2318,12 @@ pub fn is_empty(&self) -> bool { + /// `[at, len)`. After the call, the original vector will be left containing + /// the elements `[0, at)` with its previous capacity unchanged. + /// ++ /// - If you want to take ownership of the entire contents and capacity of ++ /// the vector, see [`mem::take`] or [`mem::replace`]. ++ /// - If you don't need the returned vector at all, see [`Vec::truncate`]. ++ /// - If you want to take ownership of an arbitrary subslice, or you don't ++ /// necessarily want to store the removed items in a vector, see [`Vec::drain`]. ++ /// + /// # Panics + /// + /// Panics if `at > len`. +@@ -2346,14 +2355,6 @@ fn assert_failed(at: usize, len: usize) -> ! { + assert_failed(at, self.len()); + } + +- if at == 0 { +- // the new vector can take over the original buffer and avoid the copy +- return mem::replace( +- self, +- Vec::with_capacity_in(self.capacity(), self.allocator().clone()), +- ); +- } +- + let other_len = self.len - at; + let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); + +@@ -3027,6 +3028,50 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output { + } + } + ++/// Collects an iterator into a Vec, commonly called via [`Iterator::collect()`] ++/// ++/// # Allocation behavior ++/// ++/// In general `Vec` does not guarantee any particular growth or allocation strategy. ++/// That also applies to this trait impl. ++/// ++/// **Note:** This section covers implementation details and is therefore exempt from ++/// stability guarantees. ++/// ++/// Vec may use any or none of the following strategies, ++/// depending on the supplied iterator: ++/// ++/// * preallocate based on [`Iterator::size_hint()`] ++/// * and panic if the number of items is outside the provided lower/upper bounds ++/// * use an amortized growth strategy similar to `pushing` one item at a time ++/// * perform the iteration in-place on the original allocation backing the iterator ++/// ++/// The last case warrants some attention. It is an optimization that in many cases reduces peak memory ++/// consumption and improves cache locality. But when big, short-lived allocations are created, ++/// only a small fraction of their items get collected, no further use is made of the spare capacity ++/// and the resulting `Vec` is moved into a longer-lived structure, then this can lead to the large ++/// allocations having their lifetimes unnecessarily extended which can result in increased memory ++/// footprint. ++/// ++/// In cases where this is an issue, the excess capacity can be discarded with [`Vec::shrink_to()`], ++/// [`Vec::shrink_to_fit()`] or by collecting into [`Box<[T]>`][owned slice] instead, which additionally reduces ++/// the size of the long-lived struct. ++/// ++/// [owned slice]: Box ++/// ++/// ```rust ++/// # use std::sync::Mutex; ++/// static LONG_LIVED: Mutex<Vec<Vec<u16>>> = Mutex::new(Vec::new()); ++/// ++/// for i in 0..10 { ++/// let big_temporary: Vec<u16> = (0..1024).collect(); ++/// // discard most items ++/// let mut result: Vec<_> = big_temporary.into_iter().filter(|i| i % 100 == 0).collect(); ++/// // without this a lot of unused capacity might be moved into the global ++/// result.shrink_to_fit(); ++/// LONG_LIVED.lock().unwrap().push(result); ++/// } ++/// ``` + #[cfg(not(no_global_oom_handling))] + #[stable(feature = "rust1", since = "1.0.0")] + impl<T> FromIterator<T> for Vec<T> { +@@ -3069,14 +3114,8 @@ fn into_iter(self) -> Self::IntoIter { + begin.add(me.len()) as *const T + }; + let cap = me.buf.capacity(); +- IntoIter { +- buf: NonNull::new_unchecked(begin), +- phantom: PhantomData, +- cap, +- alloc, +- ptr: begin, +- end, +- } ++ let buf = NonNull::new_unchecked(begin); ++ IntoIter { buf, phantom: PhantomData, cap, alloc, ptr: buf, end } + } + } + } +@@ -3598,8 +3637,10 @@ fn from(s: Box<[T], A>) -> Self { + impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> { + /// Convert a vector into a boxed slice. + /// +- /// If `v` has excess capacity, its items will be moved into a +- /// newly-allocated buffer with exactly the right capacity. ++ /// Before doing the conversion, this method discards excess capacity like [`Vec::shrink_to_fit`]. ++ /// ++ /// [owned slice]: Box ++ /// [`Vec::shrink_to_fit`]: Vec::shrink_to_fit + /// + /// # Examples + /// +diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs +index 75efe47522e4..f07bc5a2c6b4 100644 +--- a/rust/kernel/lib.rs ++++ b/rust/kernel/lib.rs +@@ -17,7 +17,6 @@ + #![feature(const_maybe_uninit_zeroed)] + #![feature(dispatch_from_dyn)] + #![feature(new_uninit)] +-#![feature(offset_of)] + #![feature(ptr_metadata)] + #![feature(receiver_trait)] + #![feature(unsize)] +diff --git a/scripts/Makefile.build b/scripts/Makefile.build +index 1633175846df..0bc7c5fe64b1 100644 +--- a/scripts/Makefile.build ++++ b/scripts/Makefile.build +@@ -262,7 +262,7 @@ $(obj)/%.lst: $(src)/%.c FORCE + # Compile Rust sources (.rs) + # --------------------------------------------------------------------------- + +-rust_allowed_features := new_uninit,offset_of ++rust_allowed_features := new_uninit + + # `--out-dir` is required to avoid temporaries being created by `rustc` in the + # current working directory, which may be not accessible in the out-of-tree +diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh +index e217683b10d6..db2b0bc5866b 100755 +--- a/scripts/min-tool-version.sh ++++ b/scripts/min-tool-version.sh +@@ -33,7 +33,7 @@ llvm) + fi + ;; + rustc) +- echo 1.76.0 ++ echo 1.77.1 + ;; + bindgen) + echo 0.65.1 +-- +2.44.0 + diff --git a/pkgs/os-specific/linux/kernel/rust-1.77.patch b/pkgs/os-specific/linux/kernel/rust-1.77.patch index 8bd0a5e337154..ed9eb56bf6d7e 100644 --- a/pkgs/os-specific/linux/kernel/rust-1.77.patch +++ b/pkgs/os-specific/linux/kernel/rust-1.77.patch @@ -1,14 +1,16 @@ -From d69265b7d756931b2e763a3262f22ba4100895a0 Mon Sep 17 00:00:00 2001 +From b256fc507d4710287b22077834c16d18cee4ab17 Mon Sep 17 00:00:00 2001 From: Miguel Ojeda <ojeda@kernel.org> Date: Sat, 17 Feb 2024 01:27:17 +0100 -Subject: [PATCH] rust: upgrade to Rust 1.77.0 +Subject: [PATCH] rust: upgrade to Rust 1.77.1 -This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 +This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.1 (i.e. the latest) [1]. See the upgrade policy [2] and the comments on the first upgrade in commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2"). +# Unstable features + The `offset_of` feature (single-field `offset_of!`) that we were using got stabilized in Rust 1.77.0 [3]. @@ -18,16 +20,22 @@ increase the list. Please see [4] for details. +# Required changes + Rust 1.77.0 merged the `unused_tuple_struct_fields` lint into `dead_code`, -thus upgrading it from `allow` to `warn` [5]. In turn, this makes `rustc` -complain about the `ThisModule`'s pointer field being never read. Thus -locally `allow` it for the moment, since we will have users later on -(e.g. Binder needs a `as_ptr` method [6]). +thus upgrading it from `allow` to `warn` [5]. In turn, this made `rustc` +complain about the `ThisModule`'s pointer field being never read, but +the previous patch adds the `as_ptr` method to it, needed by Binder [6], +so that we do not need to locally `allow` it. + +# Other changes Rust 1.77.0 introduces the `--check-cfg` feature [7], for which there is a Call for Testing going on [8]. We were requested to test it and we found it useful [9] -- we will likely enable it in the future. +# `alloc` upgrade and reviewing + The vast majority of changes are due to our `alloc` fork being upgraded at once. @@ -85,9 +93,12 @@ Link: https://lore.kernel.org/rust-for-linux/20231101-rust-binder-v1-2-08ba9197f Link: https://doc.rust-lang.org/nightly/unstable-book/compiler-flags/check-cfg.html [7] Link: https://github.com/rust-lang/rfcs/pull/3013#issuecomment-1936648479 [8] Link: https://github.com/rust-lang/rust/issues/82450#issuecomment-1947462977 [9] -Signed-off-by: Miguel Ojeda <ojeda@kernel.org> +Reviewed-by: Alice Ryhl <aliceryhl@google.com> +Tested-by: Boqun Feng <boqun.feng@gmail.com> Link: https://lore.kernel.org/r/20240217002717.57507-1-ojeda@kernel.org -Link: https://github.com/Rust-for-Linux/linux/commit/d69265b7d756931b2e763a3262f22ba4100895a0 +[ Upgraded to 1.77.1. Removed `allow(dead_code)` thanks to the previous + patch. Reworded accordingly. No changes to `alloc` during the beta. ] +Signed-off-by: Miguel Ojeda <ojeda@kernel.org> Signed-off-by: Alyssa Ross <hi@alyssa.is> --- Documentation/process/changes.rst | 2 +- @@ -96,15 +107,15 @@ Signed-off-by: Alyssa Ross <hi@alyssa.is> rust/alloc/lib.rs | 7 +- rust/alloc/raw_vec.rs | 13 ++-- rust/alloc/slice.rs | 4 +- - rust/alloc/vec/into_iter.rs | 108 +++++++++++++++++++----------- - rust/alloc/vec/mod.rs | 101 +++++++++++++++++++--------- - rust/kernel/lib.rs | 3 +- + rust/alloc/vec/into_iter.rs | 104 +++++++++++++++++++----------- + rust/alloc/vec/mod.rs | 101 ++++++++++++++++++++--------- + rust/kernel/lib.rs | 1 - scripts/Makefile.build | 2 +- scripts/min-tool-version.sh | 2 +- - 11 files changed, 161 insertions(+), 91 deletions(-) + 11 files changed, 158 insertions(+), 88 deletions(-) diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst -index 7ef8de58f7f892..879ee628893ae1 100644 +index 7ef8de58f7f8..b5d3107c6734 100644 --- a/Documentation/process/changes.rst +++ b/Documentation/process/changes.rst @@ -31,7 +31,7 @@ you probably needn't concern yourself with pcmciautils. @@ -112,12 +123,12 @@ index 7ef8de58f7f892..879ee628893ae1 100644 GNU C 5.1 gcc --version Clang/LLVM (optional) 13.0.1 clang --version -Rust (optional) 1.76.0 rustc --version -+Rust (optional) 1.77.0 rustc --version ++Rust (optional) 1.77.1 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 abb791cc23715a..b1204f87227b23 100644 +index abb791cc2371..b1204f87227b 100644 --- a/rust/alloc/alloc.rs +++ b/rust/alloc/alloc.rs @@ -5,7 +5,7 @@ @@ -129,7 +140,7 @@ index abb791cc23715a..b1204f87227b23 100644 #[cfg(not(test))] use core::ptr::{self, NonNull}; -@@ -210,7 +210,7 @@ impl Global { +@@ -210,7 +210,7 @@ unsafe fn grow_impl( let new_size = new_layout.size(); // `realloc` probably checks for `new_size >= old_layout.size()` or something similar. @@ -138,7 +149,7 @@ index abb791cc23715a..b1204f87227b23 100644 let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; -@@ -301,7 +301,7 @@ unsafe impl Allocator for Global { +@@ -301,7 +301,7 @@ unsafe fn shrink( // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller new_size if old_layout.align() == new_layout.align() => unsafe { // `realloc` probably checks for `new_size <= old_layout.size()` or something similar. @@ -148,7 +159,7 @@ index abb791cc23715a..b1204f87227b23 100644 let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs -index c93a22a5c97f14..5fc39dfeb8e7bf 100644 +index c93a22a5c97f..5fc39dfeb8e7 100644 --- a/rust/alloc/boxed.rs +++ b/rust/alloc/boxed.rs @@ -26,6 +26,7 @@ @@ -159,7 +170,7 @@ index c93a22a5c97f14..5fc39dfeb8e7bf 100644 //! #[derive(Debug)] //! enum List<T> { //! Cons(T, Box<List<T>>), -@@ -194,8 +195,7 @@ mod thin; +@@ -194,8 +195,7 @@ #[fundamental] #[stable(feature = "rust1", since = "1.0.0")] // The declaration of the `Box` struct must be kept in sync with the @@ -170,7 +181,7 @@ index c93a22a5c97f14..5fc39dfeb8e7bf 100644 T: ?Sized, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs -index 36f79c07559338..39afd55ec0749e 100644 +index 36f79c075593..39afd55ec074 100644 --- a/rust/alloc/lib.rs +++ b/rust/alloc/lib.rs @@ -105,7 +105,6 @@ @@ -223,7 +234,7 @@ index 36f79c07559338..39afd55ec0749e 100644 #![feature(exclusive_range_pattern)] #![feature(fundamental)] diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs -index 98b6abf30af6e4..1839d1c8ee7a04 100644 +index 98b6abf30af6..1839d1c8ee7a 100644 --- a/rust/alloc/raw_vec.rs +++ b/rust/alloc/raw_vec.rs @@ -4,7 +4,7 @@ @@ -235,7 +246,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; use core::ptr::{self, NonNull, Unique}; use core::slice; -@@ -317,7 +317,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -317,7 +317,7 @@ fn current_memory(&self) -> Option<(NonNull<u8>, Layout)> { /// /// # Panics /// @@ -244,7 +255,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 /// /// # Aborts /// -@@ -358,7 +358,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -358,7 +358,7 @@ pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryRe } unsafe { // Inform the optimizer that the reservation has succeeded or wasn't needed @@ -253,7 +264,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 } Ok(()) } -@@ -381,7 +381,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -381,7 +381,7 @@ pub fn try_reserve_for_push(&mut self, len: usize) -> Result<(), TryReserveError /// /// # Panics /// @@ -262,7 +273,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 /// /// # Aborts /// -@@ -402,7 +402,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -402,7 +402,7 @@ pub fn try_reserve_exact( } unsafe { // Inform the optimizer that the reservation has succeeded or wasn't needed @@ -271,7 +282,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 } Ok(()) } -@@ -553,7 +553,7 @@ where +@@ -553,7 +553,7 @@ fn finish_grow<A>( debug_assert_eq!(old_layout.align(), new_layout.align()); unsafe { // The allocator checks for alignment equality @@ -289,10 +300,10 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { if usize::BITS < 64 && alloc_size > isize::MAX as usize { diff --git a/rust/alloc/slice.rs b/rust/alloc/slice.rs -index 1181836da5f462..a36b072c95195f 100644 +index 1181836da5f4..a36b072c9519 100644 --- a/rust/alloc/slice.rs +++ b/rust/alloc/slice.rs -@@ -53,14 +53,14 @@ pub use core::slice::{from_mut, from_ref}; +@@ -53,14 +53,14 @@ pub use core::slice::{from_mut_ptr_range, from_ptr_range}; #[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{from_raw_parts, from_raw_parts_mut}; @@ -310,10 +321,10 @@ index 1181836da5f462..a36b072c95195f 100644 pub use core::slice::{Iter, IterMut}; #[stable(feature = "rchunks", since = "1.31.0")] diff --git a/rust/alloc/vec/into_iter.rs b/rust/alloc/vec/into_iter.rs -index 136bfe94af6c83..0f11744c44b34c 100644 +index 136bfe94af6c..0f11744c44b3 100644 --- a/rust/alloc/vec/into_iter.rs +++ b/rust/alloc/vec/into_iter.rs -@@ -20,6 +20,17 @@ use core::ops::Deref; +@@ -20,6 +20,17 @@ use core::ptr::{self, NonNull}; use core::slice::{self}; @@ -357,7 +368,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } /// Returns the remaining items of this iterator as a mutable slice. -@@ -99,7 +112,7 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -99,7 +112,7 @@ pub fn allocator(&self) -> &A { } fn as_raw_mut_slice(&mut self) -> *mut [T] { @@ -366,7 +377,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } /// Drops remaining elements and relinquishes the backing allocation. -@@ -126,7 +139,7 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -126,7 +139,7 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { // this creates less assembly self.cap = 0; self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) }; @@ -375,7 +386,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 self.end = self.buf.as_ptr(); // Dropping the remaining elements can panic, so this needs to be -@@ -138,9 +151,9 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -138,9 +151,9 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { /// Forgets to Drop the remaining elements while still allowing the backing allocation to be freed. pub(crate) fn forget_remaining_elements(&mut self) { @@ -387,7 +398,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } #[cfg(not(no_global_oom_handling))] -@@ -162,7 +175,7 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -162,7 +175,7 @@ pub(crate) fn into_vecdeque(self) -> VecDeque<T, A> { // say that they're all at the beginning of the "allocation". 0..this.len() } else { @@ -406,9 +417,6 @@ index 136bfe94af6c83..0f11744c44b34c 100644 - // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by - // reducing the `end`. - self.end = self.end.wrapping_byte_sub(1); -- -- // Make up a value of this ZST. -- Some(unsafe { mem::zeroed() }) + if T::IS_ZST { + if self.ptr.as_ptr() == self.end as *mut _ { + None @@ -416,7 +424,9 @@ index 136bfe94af6c83..0f11744c44b34c 100644 + // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by + // reducing the `end`. + self.end = self.end.wrapping_byte_sub(1); -+ + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } @@ -446,7 +456,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 }; (exact, Some(exact)) } -@@ -219,7 +238,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -219,7 +238,7 @@ fn size_hint(&self) -> (usize, Option<usize>) { #[inline] fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { let step_size = self.len().min(n); @@ -455,7 +465,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 if T::IS_ZST { // See `next` for why we sub `end` here. self.end = self.end.wrapping_byte_sub(step_size); -@@ -261,7 +280,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -261,7 +280,7 @@ fn count(self) -> usize { // Safety: `len` indicates that this many elements are available and we just checked that // it fits into the array. unsafe { @@ -464,7 +474,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 self.forget_remaining_elements(); return Err(array::IntoIter::new_unchecked(raw_ary, 0..len)); } -@@ -270,7 +289,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -270,7 +289,7 @@ fn count(self) -> usize { // Safety: `len` is larger than the array size. Copy a fixed amount here to fully initialize // the array. return unsafe { @@ -473,7 +483,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 self.ptr = self.ptr.add(N); Ok(raw_ary.transpose().assume_init()) }; -@@ -288,7 +307,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -288,7 +307,7 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item // Also note the implementation of `Self: TrustedRandomAccess` requires // that `T: Copy` so reading elements from the buffer doesn't invalidate // them for `Drop`. @@ -482,7 +492,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } } -@@ -296,18 +315,25 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -296,18 +315,25 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { #[inline] fn next_back(&mut self) -> Option<T> { @@ -491,16 +501,15 @@ index 136bfe94af6c83..0f11744c44b34c 100644 - } else if T::IS_ZST { - // See above for why 'ptr.offset' isn't used - self.end = self.end.wrapping_byte_sub(1); -- -- // Make up a value of this ZST. -- Some(unsafe { mem::zeroed() }) + if T::IS_ZST { + if self.end as *mut _ == self.ptr.as_ptr() { + None + } else { + // See above for why 'ptr.offset' isn't used + self.end = self.end.wrapping_byte_sub(1); -+ + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } @@ -518,7 +527,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } } -@@ -333,7 +359,11 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { +@@ -333,7 +359,11 @@ fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { #[stable(feature = "rust1", since = "1.0.0")] impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> { fn is_empty(&self) -> bool { @@ -532,10 +541,10 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs -index 220fb9d6f45b3f..0be27fff4554a1 100644 +index 220fb9d6f45b..0be27fff4554 100644 --- a/rust/alloc/vec/mod.rs +++ b/rust/alloc/vec/mod.rs -@@ -360,7 +360,7 @@ mod spec_extend; +@@ -360,7 +360,7 @@ /// /// `vec![x; n]`, `vec![a, b, c, d]`, and /// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec` @@ -544,7 +553,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to /// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements. /// -@@ -447,7 +447,7 @@ impl<T> Vec<T> { +@@ -447,7 +447,7 @@ pub const fn new() -> Self { /// /// # Panics /// @@ -553,7 +562,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -690,7 +690,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -690,7 +690,7 @@ pub const fn new_in(alloc: A) -> Self { /// /// # Panics /// @@ -562,7 +571,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1013,7 +1013,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1013,7 +1013,7 @@ pub fn capacity(&self) -> usize { /// /// # Panics /// @@ -571,7 +580,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1043,7 +1043,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1043,7 +1043,7 @@ pub fn reserve(&mut self, additional: usize) { /// /// # Panics /// @@ -580,7 +589,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1140,8 +1140,11 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1140,8 +1140,11 @@ pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveE /// Shrinks the capacity of the vector as much as possible. /// @@ -594,7 +603,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1191,10 +1194,10 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1191,10 +1194,10 @@ pub fn shrink_to(&mut self, min_capacity: usize) { /// Converts the vector into [`Box<[T]>`][owned slice]. /// @@ -607,7 +616,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -2017,7 +2020,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2017,7 +2020,7 @@ fn drop(&mut self) { /// /// # Panics /// @@ -616,7 +625,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -2133,7 +2136,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2133,7 +2136,7 @@ pub fn pop(&mut self) -> Option<T> { } else { unsafe { self.len -= 1; @@ -625,7 +634,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 Some(ptr::read(self.as_ptr().add(self.len()))) } } -@@ -2143,7 +2146,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2143,7 +2146,7 @@ pub fn pop(&mut self) -> Option<T> { /// /// # Panics /// @@ -634,7 +643,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -2315,6 +2318,12 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2315,6 +2318,12 @@ pub fn is_empty(&self) -> bool { /// `[at, len)`. After the call, the original vector will be left containing /// the elements `[0, at)` with its previous capacity unchanged. /// @@ -647,7 +656,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// # Panics /// /// Panics if `at > len`. -@@ -2346,14 +2355,6 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2346,14 +2355,6 @@ fn assert_failed(at: usize, len: usize) -> ! { assert_failed(at, self.len()); } @@ -662,7 +671,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 let other_len = self.len - at; let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); -@@ -3027,6 +3028,50 @@ impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> { +@@ -3027,6 +3028,50 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output { } } @@ -713,7 +722,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] impl<T> FromIterator<T> for Vec<T> { -@@ -3069,14 +3114,8 @@ impl<T, A: Allocator> IntoIterator for Vec<T, A> { +@@ -3069,14 +3114,8 @@ fn into_iter(self) -> Self::IntoIter { begin.add(me.len()) as *const T }; let cap = me.buf.capacity(); @@ -730,7 +739,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 } } } -@@ -3598,8 +3637,10 @@ impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A> { +@@ -3598,8 +3637,10 @@ fn from(s: Box<[T], A>) -> Self { impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> { /// Convert a vector into a boxed slice. /// @@ -744,7 +753,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// # Examples /// diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs -index be68d5e567b1a1..71f95e5aa09abd 100644 +index 6858e2f8a3ed..9e9b245ebab5 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -16,7 +16,6 @@ @@ -755,17 +764,8 @@ index be68d5e567b1a1..71f95e5aa09abd 100644 #![feature(receiver_trait)] #![feature(unsize)] -@@ -78,7 +77,7 @@ pub trait Module: Sized + Sync { - /// Equivalent to `THIS_MODULE` in the C API. - /// - /// C header: [`include/linux/export.h`](srctree/include/linux/export.h) --pub struct ThisModule(*mut bindings::module); -+pub struct ThisModule(#[allow(dead_code)] *mut bindings::module); - - // SAFETY: `THIS_MODULE` may be used from all threads within a module. - unsafe impl Sync for ThisModule {} diff --git a/scripts/Makefile.build b/scripts/Makefile.build -index baf86c0880b6d7..367cfeea74c5f5 100644 +index 533a7799fdfe..5a6ab6d965bc 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -263,7 +263,7 @@ $(obj)/%.lst: $(src)/%.c FORCE @@ -778,7 +778,7 @@ index baf86c0880b6d7..367cfeea74c5f5 100644 # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh -index 5927cc6b7de338..cc5141b67b4a71 100755 +index 5927cc6b7de3..6086e00e640e 100755 --- a/scripts/min-tool-version.sh +++ b/scripts/min-tool-version.sh @@ -33,7 +33,7 @@ llvm) @@ -786,7 +786,10 @@ index 5927cc6b7de338..cc5141b67b4a71 100755 ;; rustc) - echo 1.76.0 -+ echo 1.77.0 ++ echo 1.77.1 ;; bindgen) echo 0.65.1 +-- +2.44.0 + diff --git a/pkgs/os-specific/linux/kernel/xanmod-kernels.nix b/pkgs/os-specific/linux/kernel/xanmod-kernels.nix index 545bb02e95ec0..15c344efbed3d 100644 --- a/pkgs/os-specific/linux/kernel/xanmod-kernels.nix +++ b/pkgs/os-specific/linux/kernel/xanmod-kernels.nix @@ -19,6 +19,7 @@ let xanmodKernelFor = { version, suffix ? "xanmod1", hash, variant }: buildLinux (args // rec { inherit version; + pname = "linux-xanmod"; modDirVersion = lib.versions.pad 3 "${version}-${suffix}"; src = fetchFromGitHub { diff --git a/pkgs/os-specific/linux/kernel/zen-kernels.nix b/pkgs/os-specific/linux/kernel/zen-kernels.nix index 072416007e728..d0467dad0d6ec 100644 --- a/pkgs/os-specific/linux/kernel/zen-kernels.nix +++ b/pkgs/os-specific/linux/kernel/zen-kernels.nix @@ -18,6 +18,7 @@ let }; zenKernelsFor = { version, suffix, sha256, isLqx }: buildLinux (args // { inherit version; + pname = "linux-${if isLqx then "lqx" else "zen"}"; modDirVersion = lib.versions.pad 3 "${version}-${suffix}"; isZen = true; diff --git a/pkgs/os-specific/linux/kexec-tools/default.nix b/pkgs/os-specific/linux/kexec-tools/default.nix index 530fd767bb909..3861d5d0cd6f8 100644 --- a/pkgs/os-specific/linux/kexec-tools/default.nix +++ b/pkgs/os-specific/linux/kexec-tools/default.nix @@ -18,6 +18,11 @@ stdenv.mkDerivation rec { url = "https://raw.githubusercontent.com/void-linux/void-packages/6c1192cbf166698932030c2e3de71db1885a572d/srcpkgs/kexec-tools/patches/ppc64-elfv2.patch"; sha256 = "19wzfwb0azm932v0vhywv4221818qmlmvdfwpvvpfyw4hjsc2s1l"; }) + # binutils-2.42 support + (fetchpatch { + url = "https://github.com/horms/kexec-tools/commit/328de8e00e298f00d7ba6b25dc3950147e9642e6.patch"; + hash = "sha256-wVQI4oV+hBLq3kGIp2+F5J3f6s/TypDu3Xq583KYc3U="; + }) ]; hardeningDisable = [ "format" "pic" "relro" "pie" ]; diff --git a/pkgs/os-specific/linux/systemd/default.nix b/pkgs/os-specific/linux/systemd/default.nix index 0291de7242d0f..68209a4e2ccbc 100644 --- a/pkgs/os-specific/linux/systemd/default.nix +++ b/pkgs/os-specific/linux/systemd/default.nix @@ -407,6 +407,7 @@ stdenv.mkDerivation (finalAttrs: { ''; outputs = [ "out" "dev" ] ++ (lib.optional (!buildLibsOnly) "man"); + separateDebugInfo = true; hardeningDisable = [ # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111523 @@ -500,6 +501,12 @@ stdenv.mkDerivation (finalAttrs: { (lib.mesonOption "default-hierarchy" "unified") (lib.mesonOption "kmod-path" "${kmod}/bin/kmod") + # Attempts to check /usr/sbin and that fails in macOS sandbox because + # permission is denied. If /usr/sbin is not a symlink, it defaults to true. + # We set it to false since stdenv moves sbin/* to bin and creates a symlink, + # that is, we do not have split bin. + (lib.mesonOption "split-bin" "false") + # D-Bus (lib.mesonOption "dbuspolicydir" "${placeholder "out"}/share/dbus-1/system.d") (lib.mesonOption "dbussessionservicedir" "${placeholder "out"}/share/dbus-1/services") @@ -814,6 +821,9 @@ stdenv.mkDerivation (finalAttrs: { substituteInPlace $i --replace /bin/false ${coreutils}/bin/false done + # For compatibility with dependents that use sbin instead of bin. + ln -s bin "$out/sbin" + rm -rf $out/etc/rpm '' + lib.optionalString (!withKernelInstall) '' # "kernel-install" shouldn't be used on NixOS. diff --git a/pkgs/os-specific/linux/util-linux/default.nix b/pkgs/os-specific/linux/util-linux/default.nix index b76579ecb4353..e393bf1ac08e6 100644 --- a/pkgs/os-specific/linux/util-linux/default.nix +++ b/pkgs/os-specific/linux/util-linux/default.nix @@ -1,9 +1,7 @@ -{ lib, stdenv, fetchurl, pkg-config -, zlib, shadow +{ lib, stdenv, fetchurl, pkg-config, zlib, shadow , capabilitiesSupport ? stdenv.isLinux , libcap_ng , libxcrypt -, sqlite , ncursesSupport ? true , ncurses , pamSupport ? true @@ -19,20 +17,14 @@ , memstreamHook , gitUpdater }: -let - # Temporarily avoid applying the patches on systems where already we have binaries - # (in particular x86_64-linux and aarch64-linux) as the package is a huge rebuild there. - avoidRebuild = with stdenv.hostPlatform; isLinux && is64bit && !isStatic; -in + stdenv.mkDerivation rec { pname = "util-linux" + lib.optionalString (!nlsSupport && !ncursesSupport && !systemdSupport) "-minimal"; - version = if avoidRebuild then "2.40.1" else "2.39.4"; + version = "2.39.4"; src = fetchurl { url = "mirror://kernel/linux/utils/util-linux/v${lib.versions.majorMinor version}/util-linux-${version}.tar.xz"; - hash = if avoidRebuild - then "sha256-WeZ2qlPMtEtsOfD/4BqPonSJHJG+8UdHUvrZJGHe8k8=" - else "sha256-bE+HI9r9QcOdk+y/FlCfyIwzzVvTJ3iArlodl6AU/Q4="; + hash = "sha256-bE+HI9r9QcOdk+y/FlCfyIwzzVvTJ3iArlodl6AU/Q4="; }; patches = [ @@ -48,7 +40,7 @@ stdenv.mkDerivation rec { separateDebugInfo = true; postPatch = '' - patchShebangs tests/run.sh tools/all_syscalls + patchShebangs tests/run.sh substituteInPlace sys-utils/eject.c \ --replace "/bin/umount" "$bin/bin/umount" @@ -67,7 +59,6 @@ stdenv.mkDerivation rec { "--enable-fs-paths-default=/run/wrappers/bin:/run/current-system/sw/bin:/sbin" "--disable-makeinstall-setuid" "--disable-makeinstall-chown" "--disable-su" # provided by shadow - "--with-tmpfilesdir=${placeholder "out"}/lib/tmpfiles.d" (lib.enableFeature writeSupport "write") (lib.enableFeature nlsSupport "nls") (lib.withFeature ncursesSupport "ncursesw") @@ -89,7 +80,7 @@ stdenv.mkDerivation rec { nativeBuildInputs = [ pkg-config installShellFiles ] ++ lib.optionals translateManpages [ po4a ]; - buildInputs = [ zlib libxcrypt sqlite ] + buildInputs = [ zlib libxcrypt ] ++ lib.optionals pamSupport [ pam ] ++ lib.optionals capabilitiesSupport [ libcap_ng ] ++ lib.optionals ncursesSupport [ ncurses ] @@ -118,6 +109,9 @@ stdenv.mkDerivation rec { ln -svf "$swap/bin/"* $bin/bin/ '' + '' + ln -svf "$bin/bin/hexdump" "$bin/bin/hd" + ln -svf "$man/share/man/man1/hexdump.1" "$man/share/man/man1/hd.1" + installShellCompletion --bash bash-completion/* ''; |