From: Greg Kroah-Hartman Date: Sun, 9 Mar 2025 21:02:26 +0000 (+0100) Subject: 6.12-stable patches X-Git-Tag: v5.4.291~78 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=95790a9c7e5fea0e2985e9e9a109dd15e6cc1df2;p=thirdparty%2Fkernel%2Fstable-queue.git 6.12-stable patches added patches: rust-finish-using-custom-ffi-integer-types.patch rust-map-long-to-isize-and-char-to-u8.patch --- diff --git a/queue-6.12/rust-finish-using-custom-ffi-integer-types.patch b/queue-6.12/rust-finish-using-custom-ffi-integer-types.patch new file mode 100644 index 0000000000..2a3cc33f5e --- /dev/null +++ b/queue-6.12/rust-finish-using-custom-ffi-integer-types.patch @@ -0,0 +1,45 @@ +From stable+bounces-121622-greg=kroah.com@vger.kernel.org Sun Mar 9 21:42:38 2025 +From: Miguel Ojeda +Date: Sun, 9 Mar 2025 21:42:16 +0100 +Subject: rust: finish using custom FFI integer types +To: Greg Kroah-Hartman , Sasha Levin , stable@vger.kernel.org +Cc: Danilo Krummrich , Alice Ryhl , Alyssa Ross , NoisyCoil , patches@lists.linux.dev, Miguel Ojeda +Message-ID: <20250309204217.1553389-2-ojeda@kernel.org> + +From: Miguel Ojeda + +commit 27c7518e7f1ccaaa43eb5f25dc362779d2dc2ccb upstream. + +In the last kernel cycle we migrated most of the `core::ffi` cases in +commit d072acda4862 ("rust: use custom FFI integer types"): + + Currently FFI integer types are defined in libcore. This commit + creates the `ffi` crate and asks bindgen to use that crate for FFI + integer types instead of `core::ffi`. + + This commit is preparatory and no type changes are made in this + commit yet. + +Finish now the few remaining/new cases so that we perform the actual +remapping in the next commit as planned. + +Acked-by: Jocelyn Falempe # drm +Link: https://lore.kernel.org/rust-for-linux/CANiq72m_rg42SvZK=bF2f0yEoBLVA33UBhiAsv8THhVu=G2dPA@mail.gmail.com/ +Link: https://lore.kernel.org/all/cc9253fa-9d5f-460b-9841-94948fb6580c@redhat.com/ +Signed-off-by: Miguel Ojeda +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpu/drm/drm_panic_qr.rs | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/gpu/drm/drm_panic_qr.rs ++++ b/drivers/gpu/drm/drm_panic_qr.rs +@@ -931,7 +931,7 @@ impl QrImage<'_> { + /// They must remain valid for the duration of the function call. + #[no_mangle] + pub unsafe extern "C" fn drm_panic_qr_generate( +- url: *const i8, ++ url: *const kernel::ffi::c_char, + data: *mut u8, + data_len: usize, + data_size: usize, diff --git a/queue-6.12/rust-map-long-to-isize-and-char-to-u8.patch b/queue-6.12/rust-map-long-to-isize-and-char-to-u8.patch new file mode 100644 index 0000000000..110907e482 --- /dev/null +++ b/queue-6.12/rust-map-long-to-isize-and-char-to-u8.patch @@ -0,0 +1,190 @@ +From stable+bounces-121623-greg=kroah.com@vger.kernel.org Sun Mar 9 21:42:43 2025 +From: Miguel Ojeda +Date: Sun, 9 Mar 2025 21:42:17 +0100 +Subject: rust: map `long` to `isize` and `char` to `u8` +To: Greg Kroah-Hartman , Sasha Levin , stable@vger.kernel.org +Cc: Danilo Krummrich , Alice Ryhl , Alyssa Ross , NoisyCoil , patches@lists.linux.dev, Miguel Ojeda +Message-ID: <20250309204217.1553389-3-ojeda@kernel.org> + +From: Gary Guo + +commit 1bae8729e50a900f41e9a1c17ae81113e4cf62b8 upstream. + +The following FFI types are replaced compared to `core::ffi`: + +1. `char` type is now always mapped to `u8`, since kernel uses + `-funsigned-char` on the C code. `core::ffi` maps it to platform + default ABI, which can be either signed or unsigned. + +2. `long` is now always mapped to `isize`. It's very common in the + kernel to use `long` to represent a pointer-sized integer, and in + fact `intptr_t` is a typedef of `long` in the kernel. Enforce this + mapping rather than mapping to `i32/i64` depending on platform can + save us a lot of unnecessary casts. + +Signed-off-by: Gary Guo +Reviewed-by: Alice Ryhl +Link: https://lore.kernel.org/r/20240913213041.395655-5-gary@garyguo.net +[ Moved `uaccess` changes from the next commit, since they were + irrefutable patterns that Rust >= 1.82.0 warns about. Reworded + slightly and reformatted a few documentation comments. Rebased on + top of `rust-next`. Added the removal of two casts to avoid Clippy + warnings. - Miguel ] +Signed-off-by: Miguel Ojeda +Signed-off-by: Greg Kroah-Hartman +--- + rust/ffi.rs | 37 ++++++++++++++++++++++++++++++++++++- + rust/kernel/error.rs | 5 +---- + rust/kernel/firmware.rs | 2 +- + rust/kernel/uaccess.rs | 27 +++++++-------------------- + 4 files changed, 45 insertions(+), 26 deletions(-) + +--- a/rust/ffi.rs ++++ b/rust/ffi.rs +@@ -10,4 +10,39 @@ + + #![no_std] + +-pub use core::ffi::*; ++macro_rules! alias { ++ ($($name:ident = $ty:ty;)*) => {$( ++ #[allow(non_camel_case_types, missing_docs)] ++ pub type $name = $ty; ++ ++ // Check size compatibility with `core`. ++ const _: () = assert!( ++ core::mem::size_of::<$name>() == core::mem::size_of::() ++ ); ++ )*} ++} ++ ++alias! { ++ // `core::ffi::c_char` is either `i8` or `u8` depending on architecture. In the kernel, we use ++ // `-funsigned-char` so it's always mapped to `u8`. ++ c_char = u8; ++ ++ c_schar = i8; ++ c_uchar = u8; ++ ++ c_short = i16; ++ c_ushort = u16; ++ ++ c_int = i32; ++ c_uint = u32; ++ ++ // In the kernel, `intptr_t` is defined to be `long` in all platforms, so we can map the type to ++ // `isize`. ++ c_long = isize; ++ c_ulong = usize; ++ ++ c_longlong = i64; ++ c_ulonglong = u64; ++} ++ ++pub use core::ffi::c_void; +--- a/rust/kernel/error.rs ++++ b/rust/kernel/error.rs +@@ -153,11 +153,8 @@ impl Error { + + /// Returns the error encoded as a pointer. + pub fn to_ptr(self) -> *mut T { +- #[cfg_attr(target_pointer_width = "32", allow(clippy::useless_conversion))] + // SAFETY: `self.0` is a valid error due to its invariant. +- unsafe { +- bindings::ERR_PTR(self.0.get().into()) as *mut _ +- } ++ unsafe { bindings::ERR_PTR(self.0.get() as _) as *mut _ } + } + + /// Returns a string representing the error, if one exists. +--- a/rust/kernel/firmware.rs ++++ b/rust/kernel/firmware.rs +@@ -12,7 +12,7 @@ use core::ptr::NonNull; + /// One of the following: `bindings::request_firmware`, `bindings::firmware_request_nowarn`, + /// `bindings::firmware_request_platform`, `bindings::request_firmware_direct`. + struct FwFunc( +- unsafe extern "C" fn(*mut *const bindings::firmware, *const i8, *mut bindings::device) -> i32, ++ unsafe extern "C" fn(*mut *const bindings::firmware, *const u8, *mut bindings::device) -> i32, + ); + + impl FwFunc { +--- a/rust/kernel/uaccess.rs ++++ b/rust/kernel/uaccess.rs +@@ -8,7 +8,7 @@ use crate::{ + alloc::Flags, + bindings, + error::Result, +- ffi::{c_ulong, c_void}, ++ ffi::c_void, + prelude::*, + types::{AsBytes, FromBytes}, + }; +@@ -224,13 +224,9 @@ impl UserSliceReader { + if len > self.length { + return Err(EFAULT); + } +- let Ok(len_ulong) = c_ulong::try_from(len) else { +- return Err(EFAULT); +- }; +- // SAFETY: `out_ptr` points into a mutable slice of length `len_ulong`, so we may write ++ // SAFETY: `out_ptr` points into a mutable slice of length `len`, so we may write + // that many bytes to it. +- let res = +- unsafe { bindings::copy_from_user(out_ptr, self.ptr as *const c_void, len_ulong) }; ++ let res = unsafe { bindings::copy_from_user(out_ptr, self.ptr as *const c_void, len) }; + if res != 0 { + return Err(EFAULT); + } +@@ -259,9 +255,6 @@ impl UserSliceReader { + if len > self.length { + return Err(EFAULT); + } +- let Ok(len_ulong) = c_ulong::try_from(len) else { +- return Err(EFAULT); +- }; + let mut out: MaybeUninit = MaybeUninit::uninit(); + // SAFETY: The local variable `out` is valid for writing `size_of::()` bytes. + // +@@ -272,7 +265,7 @@ impl UserSliceReader { + bindings::_copy_from_user( + out.as_mut_ptr().cast::(), + self.ptr as *const c_void, +- len_ulong, ++ len, + ) + }; + if res != 0 { +@@ -335,12 +328,9 @@ impl UserSliceWriter { + if len > self.length { + return Err(EFAULT); + } +- let Ok(len_ulong) = c_ulong::try_from(len) else { +- return Err(EFAULT); +- }; +- // SAFETY: `data_ptr` points into an immutable slice of length `len_ulong`, so we may read ++ // SAFETY: `data_ptr` points into an immutable slice of length `len`, so we may read + // that many bytes from it. +- let res = unsafe { bindings::copy_to_user(self.ptr as *mut c_void, data_ptr, len_ulong) }; ++ let res = unsafe { bindings::copy_to_user(self.ptr as *mut c_void, data_ptr, len) }; + if res != 0 { + return Err(EFAULT); + } +@@ -359,9 +349,6 @@ impl UserSliceWriter { + if len > self.length { + return Err(EFAULT); + } +- let Ok(len_ulong) = c_ulong::try_from(len) else { +- return Err(EFAULT); +- }; + // SAFETY: The reference points to a value of type `T`, so it is valid for reading + // `size_of::()` bytes. + // +@@ -372,7 +359,7 @@ impl UserSliceWriter { + bindings::_copy_to_user( + self.ptr as *mut c_void, + (value as *const T).cast::(), +- len_ulong, ++ len, + ) + }; + if res != 0 { diff --git a/queue-6.12/series b/queue-6.12/series index fcd8f9fbdd..af22e27326 100644 --- a/queue-6.12/series +++ b/queue-6.12/series @@ -226,3 +226,5 @@ usb-gadget-fix-setting-self-powered-state-on-suspend.patch usb-gadget-check-bmattributes-only-if-configuration-is-valid.patch kbuild-userprogs-use-correct-lld-when-linking-through-clang.patch acpi-typec-ucsi-introduce-a-poll_cci-method.patch +rust-finish-using-custom-ffi-integer-types.patch +rust-map-long-to-isize-and-char-to-u8.patch