Merge tag 'rust-6.18' of git://git.kernel.org/pub/scm/linux/kernel/git/ojeda/linux

Pull rust updates from Miguel Ojeda: "Toolchain and infrastructure: - Derive 'Zeroable' for all structs and unions generated by 'bindgen' where possible and corresponding cleanups. To do so, add the 'pin-init' crate as a dependency to 'bindings' and 'uapi'. It also includes its first use in the 'cpufreq' module, with more to come in the next cycle. - Add warning to the 'rustdoc' target to detect broken 'srctree/' links and fix existing cases. - Remove support for unused (since v6.16) host '#[test]'s, simplifying the 'rusttest' target. Tests should generally run within KUnit. 'kernel' crate: - Add 'ptr' module with a new 'Alignment' type, which is always a power of two and is used to validate that a given value is a valid alignment and to perform masking and alignment operations: // Checked at build time. assert_eq!(Alignment::new::<16>().as_usize(), 16); // Checked at runtime. assert_eq!(Alignment::new_checked(15), None); assert_eq!(Alignment::of::<u8>().log2(), 0); assert_eq!(0x25u8.align_down(Alignment::new::<0x10>()), 0x20); assert_eq!(0x5u8.align_up(Alignment::new::<0x10>()), Some(0x10)); assert_eq!(u8::MAX.align_up(Alignment::new::<0x10>()), None); It also includes its first use in Nova. - Add 'core::mem::{align,size}_of{,_val}' to the prelude, matching Rust 1.80.0. - Keep going with the steps on our migration to the standard library 'core::ffi::CStr' type (use 'kernel::{fmt, prelude::fmt!}' and use upstream method names). - 'error' module: improve 'Error::from_errno' and 'to_result' documentation, including examples/tests. - 'sync' module: extend 'aref' submodule documentation now that it exists, and more updates to complete the ongoing move of 'ARef' and 'AlwaysRefCounted' to 'sync::aref'. - 'list' module: add an example/test for 'ListLinksSelfPtr' usage. - 'alloc' module: - Implement 'Box::pin_slice()', which constructs a pinned slice of elements. - Provide information about the minimum alignment guarantees of 'Kmalloc', 'Vmalloc' and 'KVmalloc'. - Take minimum alignment guarantees of allocators for 'ForeignOwnable' into account. - Remove the 'allocator_test' (including 'Cmalloc'). - Add doctest for 'Vec::as_slice()'. - Constify various methods. - 'time' module: - Add methods on 'HrTimer' that can only be called with exclusive access to an unarmed timer, or from timer callback context. - Add arithmetic operations to 'Instant' and 'Delta'. - Add a few convenience and access methods to 'HrTimer' and 'Instant'. 'macros' crate: - Reduce collections in 'quote!' macro. And a few other cleanups and improvements" * tag 'rust-6.18' of git://git.kernel.org/pub/scm/linux/kernel/git/ojeda/linux: (58 commits) gpu: nova-core: use Alignment for alignment-related operations rust: add `Alignment` type rust: macros: reduce collections in `quote!` macro rust: acpi: use `core::ffi::CStr` method names rust: of: use `core::ffi::CStr` method names rust: net: use `core::ffi::CStr` method names rust: miscdevice: use `core::ffi::CStr` method names rust: kunit: use `core::ffi::CStr` method names rust: firmware: use `core::ffi::CStr` method names rust: drm: use `core::ffi::CStr` method names rust: cpufreq: use `core::ffi::CStr` method names rust: configfs: use `core::ffi::CStr` method names rust: auxiliary: use `core::ffi::CStr` method names drm/panic: use `core::ffi::CStr` method names rust: device: use `kernel::{fmt,prelude::fmt!}` rust: sync: use `kernel::{fmt,prelude::fmt!}` rust: seq_file: use `kernel::{fmt,prelude::fmt!}` rust: kunit: use `kernel::{fmt,prelude::fmt!}` rust: file: use `kernel::{fmt,prelude::fmt!}` rust: device: use `kernel::{fmt,prelude::fmt!}` ...

Linus Torvalds committed 1 year ago

Commit f4e0ff72 parents ae28ed4 f3f6b3661 files · +1054 −315Browse files

Unified · Split

61 files

Documentation/gpu/nova/core/todo.rst +0 −1
drivers/block/rnull.rs +1 −1
drivers/gpu/drm/drm_panic_qr.rs +1 −1
drivers/gpu/nova-core/fb.rs +3 −3
drivers/gpu/nova-core/gpu.rs +1 −2
drivers/gpu/nova-core/regs/macros.rs +3 −3
drivers/gpu/nova-core/vbios.rs +2 −2
rust/Makefile +15 −14
rust/bindgen_parameters +5 −0
rust/bindings/bindings_helper.h +1 −0
rust/bindings/lib.rs +8 −0
rust/kernel/acpi.rs +2 −5
rust/kernel/alloc.rs +8 −7
rust/kernel/alloc/allocator.rs +8 −0
rust/kernel/alloc/allocator_test.rs +0 −124
rust/kernel/alloc/kbox.rs +87 −5
rust/kernel/alloc/kvec.rs +17 −7
rust/kernel/alloc/kvec/errors.rs +1 −1
rust/kernel/alloc/layout.rs +1 −1
rust/kernel/auxiliary.rs +2 −2
rust/kernel/block/mq.rs +1 −1
rust/kernel/block/mq/gen_disk.rs +2 −2
rust/kernel/block/mq/raw_writer.rs +1 −2
rust/kernel/configfs.rs +2 −2
rust/kernel/cpu.rs +1 −0
rust/kernel/cpufreq.rs +2 −4
rust/kernel/device.rs +3 −3
rust/kernel/device/property.rs +12 −11
rust/kernel/dma.rs +1 −1
rust/kernel/drm/device.rs +3 −3
rust/kernel/drm/driver.rs +1 −1
rust/kernel/drm/file.rs +1 −1
rust/kernel/drm/gem/mod.rs +1 −1
rust/kernel/drm/ioctl.rs +1 −1
rust/kernel/error.rs +59 −7
rust/kernel/firmware.rs +1 −1
rust/kernel/fs/file.rs +3 −2
rust/kernel/kunit.rs +7 −7
rust/kernel/lib.rs +4 −1
rust/kernel/list.rs +120 −0
rust/kernel/miscdevice.rs +1 −1
rust/kernel/net/phy.rs +1 −1
rust/kernel/of.rs +1 −1
rust/kernel/prelude.rs +4 −1
rust/kernel/ptr.rs +228 −0
rust/kernel/seq_file.rs +3 −3
rust/kernel/sync/arc.rs +4 −4
rust/kernel/sync/aref.rs +16 −1
rust/kernel/task.rs +4 −3
rust/kernel/time.rs +162 −1
rust/kernel/time/hrtimer.rs +149 −3
rust/kernel/time/hrtimer/arc.rs +8 −1
rust/kernel/time/hrtimer/pin.rs +8 −1
rust/kernel/time/hrtimer/pin_mut.rs +9 −3
rust/kernel/time/hrtimer/tbox.rs +8 −1
rust/macros/quote.rs +49 −55
rust/uapi/lib.rs +2 −0
samples/rust/rust_configfs.rs +1 −1
samples/rust/rust_dma.rs +1 −1
scripts/generate_rust_analyzer.py +2 −2
scripts/rustdoc_test_gen.rs +1 −1

Documentation/gpu/nova/core/todo.rst+0−1

@@ -147,7 +147,6 @@ Numerical operations [NUMM] · 146 unmodified lines
147	Nova uses integer operations that are not part of the standard library (or not	147	Nova uses integer operations that are not part of the standard library (or not
148	implemented in an optimized way for the kernel). These include:	148	implemented in an optimized way for the kernel). These include:
149		149
150	- Aligning up and down to a power of two,
151	- The "Find Last Set Bit" (`fls` function of the C part of the kernel)	150	- The "Find Last Set Bit" (`fls` function of the C part of the kernel)
152	operation.	151	operation.
153		152

drivers/block/rnull.rs+1−1

@@ -51,7 +51,7 @@ impl kernel::InPlaceModule for NullBlkModule { · 50 unmodified lines
51	.logical_block_size(4096)?	51	.logical_block_size(4096)?
52	.physical_block_size(4096)?	52	.physical_block_size(4096)?
53	.rotational(false)	53	.rotational(false)
54	.build(format_args!("rnullb{}", 0), tagset)	54	.build(fmt!("rnullb{}", 0), tagset)
55	})();	55	})();
56		56
57	try_pin_init!(Self {	57	try_pin_init!(Self {

drivers/gpu/drm/drm_panic_qr.rs+1−1

@@ -968,7 +968,7 @@ pub unsafe extern "C" fn drm_panic_qr_generate( · 967 unmodified lines
968	// nul-terminated string.	968	// nul-terminated string.
969	let url_cstr: &CStr = unsafe { CStr::from_char_ptr(url) };	969	let url_cstr: &CStr = unsafe { CStr::from_char_ptr(url) };
970	let segments = &[	970	let segments = &[
971	&Segment::Binary(url_cstr.as_bytes()),	971	&Segment::Binary(url_cstr.to_bytes()),
972	&Segment::Numeric(&data_slice[0..data_len]),	972	&Segment::Numeric(&data_slice[0..data_len]),
973	];	973	];
974	match EncodedMsg::new(segments, tmp_slice) {	974	match EncodedMsg::new(segments, tmp_slice) {

drivers/gpu/nova-core/fb.rs+3−3

 use core::ops::Range;
 use kernel::prelude::*;
+use kernel::ptr::{Alignable, Alignment};
 use kernel::sizes::*;
 use kernel::types::ARef;
 use kernel::{dev_warn, device};
         };
         let frts = {
-            const FRTS_DOWN_ALIGN: u64 = SZ_128K as u64;
+            const FRTS_DOWN_ALIGN: Alignment = Alignment::new::<SZ_128K>();
             const FRTS_SIZE: u64 = SZ_1M as u64;
-            // TODO[NUMM]: replace with `align_down` once it lands.
+            let frts_base = vga_workspace.start.align_down(FRTS_DOWN_ALIGN) - FRTS_SIZE;
-            let frts_base = (vga_workspace.start & !(FRTS_DOWN_ALIGN - 1)) - FRTS_SIZE;
             frts_base..frts_base + FRTS_SIZE
         };

drivers/gpu/nova-core/gpu.rs+1−2

 // SPDX-License-Identifier: GPL-2.0
-use kernel::{device, devres::Devres, error::code::*, pci, prelude::*, sync::Arc};
+use kernel::{device, devres::Devres, error::code::*, fmt, pci, prelude::*, sync::Arc};
 use crate::driver::Bar0;
 use crate::falcon::{gsp::Gsp, sec2::Sec2, Falcon};
 use crate::regs;
 use crate::util;
 use crate::vbios::Vbios;
-use core::fmt;
 macro_rules! define_chipset {
     ({ $($variant:ident = $value:expr),* $(,)* }) =>

drivers/gpu/nova-core/regs/macros.rs+3−3

@@ -149,10 +149,10 @@ macro_rules! register { · 148 unmodified lines
149		149
150	// TODO[REGA]: display the raw hex value, then the value of all the fields. This requires	150	// TODO[REGA]: display the raw hex value, then the value of all the fields. This requires
151	// matching the fields, which will complexify the syntax considerably...	151	// matching the fields, which will complexify the syntax considerably...
152	impl ::core::fmt::Debug for $name {	152	impl ::kernel::fmt::Debug for $name {
153	fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {	153	fn fmt(&self, f: &mut ::kernel::fmt::Formatter<'_>) -> ::kernel::fmt::Result {
154	f.debug_tuple(stringify!($name))	154	f.debug_tuple(stringify!($name))
155	.field(&format_args!("0x{0:x}", &self.0))	155	.field(&::kernel::prelude::fmt!("0x{0:x}", &self.0))
156	.finish()	156	.finish()
157	}	157	}
158	}	158	}

drivers/gpu/nova-core/vbios.rs+2−2

 use kernel::error::Result;
 use kernel::pci;
 use kernel::prelude::*;
+use kernel::ptr::{Alignable, Alignment};
 /// The offset of the VBIOS ROM in the BAR0 space.
 const ROM_OFFSET: usize = 0x300000;
         // Advance to next image (aligned to 512 bytes).
         self.current_offset += image_size;
-        // TODO[NUMM]: replace with `align_up` once it lands.
+        self.current_offset = self.current_offset.align_up(Alignment::new::<512>())?;
-        self.current_offset = self.current_offset.next_multiple_of(512);
         Some(Ok(full_image))
     }

rust/Makefile+15−14

 # and then retouch the generated files.
 rustdoc: rustdoc-core rustdoc-macros rustdoc-compiler_builtins \
     rustdoc-kernel rustdoc-pin_init
+	$(Q)grep -Ehro '<a href="srctree/([^"]+)"' $(rustdoc_output) | \
+		cut -d'"' -f2 | cut -d/ -f2- | while read f; do \
+			if [ ! -e "$(srctree)/$$f" ]; then \
+				echo "warning: srctree/ link to $$f does not exist"; \
+			fi \
+		done
 	$(Q)cp $(srctree)/Documentation/images/logo.svg $(rustdoc_output)/static.files/
 	$(Q)cp $(srctree)/Documentation/images/COPYING-logo $(rustdoc_output)/static.files/
 	$(Q)find $(rustdoc_output) -name '*.html' -type f -print0 | xargs -0 sed -Ei \
     $(obj)/bindings.o FORCE
 	+$(call if_changed,rustc_test_library)
-rusttestlib-bindings: private rustc_target_flags = --extern ffi
+rusttestlib-bindings: private rustc_target_flags = --extern ffi --extern pin_init
-rusttestlib-bindings: $(src)/bindings/lib.rs rusttestlib-ffi FORCE
+rusttestlib-bindings: $(src)/bindings/lib.rs rusttestlib-ffi rusttestlib-pin_init FORCE
 	+$(call if_changed,rustc_test_library)
-rusttestlib-uapi: private rustc_target_flags = --extern ffi
+rusttestlib-uapi: private rustc_target_flags = --extern ffi --extern pin_init
-rusttestlib-uapi: $(src)/uapi/lib.rs rusttestlib-ffi FORCE
+rusttestlib-uapi: $(src)/uapi/lib.rs rusttestlib-ffi rusttestlib-pin_init FORCE
 	+$(call if_changed,rustc_test_library)
 quiet_cmd_rustdoc_test = RUSTDOC T $<
 	$(objtree)/$(obj)/test/$(subst rusttest-,,$@) $(rust_test_quiet) \
 		$(rustc_test_run_flags)
-rusttest: rusttest-macros rusttest-kernel
+rusttest: rusttest-macros
 rusttest-macros: private rustc_target_flags = --extern proc_macro \
 	--extern macros --extern kernel --extern pin_init
 	+$(call if_changed,rustc_test)
 	+$(call if_changed,rustdoc_test)
-rusttest-kernel: private rustc_target_flags = --extern ffi --extern pin_init \
-    --extern build_error --extern macros --extern bindings --extern uapi
-rusttest-kernel: $(src)/kernel/lib.rs rusttestlib-ffi rusttestlib-kernel \
-    rusttestlib-build_error rusttestlib-macros rusttestlib-bindings \
-    rusttestlib-uapi rusttestlib-pin_init FORCE
-	+$(call if_changed,rustc_test)
 ifdef CONFIG_CC_IS_CLANG
 bindgen_c_flags = $(c_flags)
 else
 $(obj)/ffi.o: $(src)/ffi.rs $(obj)/compiler_builtins.o FORCE
 	+$(call if_changed_rule,rustc_library)
-$(obj)/bindings.o: private rustc_target_flags = --extern ffi
+$(obj)/bindings.o: private rustc_target_flags = --extern ffi --extern pin_init
 $(obj)/bindings.o: $(src)/bindings/lib.rs \
     $(obj)/ffi.o \
+    $(obj)/pin_init.o \
     $(obj)/bindings/bindings_generated.rs \
     $(obj)/bindings/bindings_helpers_generated.rs FORCE
 	+$(call if_changed_rule,rustc_library)
-$(obj)/uapi.o: private rustc_target_flags = --extern ffi
+$(obj)/uapi.o: private rustc_target_flags = --extern ffi --extern pin_init
 $(obj)/uapi.o: private skip_gendwarfksyms = 1
 $(obj)/uapi.o: $(src)/uapi/lib.rs \
     $(obj)/ffi.o \
+    $(obj)/pin_init.o \
     $(obj)/uapi/uapi_generated.rs FORCE
 	+$(call if_changed_rule,rustc_library)

rust/bindgen_parameters+5−0

@@ -34,3 +34,8 @@ · 33 unmodified lines
34	# We use const helpers to aid bindgen, to avoid conflicts when constants are	34	# We use const helpers to aid bindgen, to avoid conflicts when constants are
35	# recognized, block generation of the non-helper constants.	35	# recognized, block generation of the non-helper constants.
36	--blocklist-item ARCH_SLAB_MINALIGN	36	--blocklist-item ARCH_SLAB_MINALIGN
		37	--blocklist-item ARCH_KMALLOC_MINALIGN
		38
		39	# Structs should implement `Zeroable` when all of their fields do.
		40	--with-derive-custom-struct .*=MaybeZeroable
		41	--with-derive-custom-union .*=MaybeZeroable

rust/bindings/bindings_helper.h+1−0

@@ -84,6 +84,7 @@ · 83 unmodified lines
84		84
85	/* `bindgen` gets confused at certain things. */	85	/* `bindgen` gets confused at certain things. */
86	const size_t RUST_CONST_HELPER_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;	86	const size_t RUST_CONST_HELPER_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;
		87	const size_t RUST_CONST_HELPER_ARCH_KMALLOC_MINALIGN = ARCH_KMALLOC_MINALIGN;
87	const size_t RUST_CONST_HELPER_PAGE_SIZE = PAGE_SIZE;	88	const size_t RUST_CONST_HELPER_PAGE_SIZE = PAGE_SIZE;
88	const gfp_t RUST_CONST_HELPER_GFP_ATOMIC = GFP_ATOMIC;	89	const gfp_t RUST_CONST_HELPER_GFP_ATOMIC = GFP_ATOMIC;
89	const gfp_t RUST_CONST_HELPER_GFP_KERNEL = GFP_KERNEL;	90	const gfp_t RUST_CONST_HELPER_GFP_KERNEL = GFP_KERNEL;

rust/bindings/lib.rs+8−0

 #[allow(clippy::undocumented_unsafe_blocks)]
 #[cfg_attr(CONFIG_RUSTC_HAS_UNNECESSARY_TRANSMUTES, allow(unnecessary_transmutes))]
 mod bindings_raw {
+    use pin_init::{MaybeZeroable, Zeroable};
     // Manual definition for blocklisted types.
     type __kernel_size_t = usize;
     type __kernel_ssize_t = isize;
     type __kernel_ptrdiff_t = isize;
+    // `bindgen` doesn't automatically do this, see
+    // <https://github.com/rust-lang/rust-bindgen/issues/3196>
+    //
+    // SAFETY: `__BindgenBitfieldUnit<Storage>` is a newtype around `Storage`.
+    unsafe impl<Storage> Zeroable for __BindgenBitfieldUnit<Storage> where Storage: Zeroable {}
     // Use glob import here to expose all helpers.
     // Symbols defined within the module will take precedence to the glob import.
     pub use super::bindings_helper::*;

rust/kernel/acpi.rs+2−5

     /// Create a new device id from an ACPI 'id' string.
     #[inline(always)]
     pub const fn new(id: &'static CStr) -> Self {
-        build_assert!(
+        let src = id.to_bytes_with_nul();
-            id.len_with_nul() <= Self::ACPI_ID_LEN,
+        build_assert!(src.len() <= Self::ACPI_ID_LEN, "ID exceeds 16 bytes");
-            "ID exceeds 16 bytes"
-        );
-        let src = id.as_bytes_with_nul();
         // Replace with `bindings::acpi_device_id::default()` once stabilized for `const`.
         // SAFETY: FFI type is valid to be zero-initialized.
         let mut acpi: bindings::acpi_device_id = unsafe { core::mem::zeroed() };

rust/kernel/alloc.rs+8−7

 //! Implementation of the kernel's memory allocation infrastructure.
-#[cfg(not(any(test, testlib)))]
 pub mod allocator;
 pub mod kbox;
 pub mod kvec;
 pub mod layout;
-#[cfg(any(test, testlib))]
-pub mod allocator_test;
-#[cfg(any(test, testlib))]
-pub use self::allocator_test as allocator;
 pub use self::kbox::Box;
 pub use self::kbox::KBox;
 pub use self::kbox::KVBox;
 /// - Implementers must ensure that all trait functions abide by the guarantees documented in the
 ///   `# Guarantees` sections.
 pub unsafe trait Allocator {
+    /// The minimum alignment satisfied by all allocations from this allocator.
+    ///
+    /// # Guarantees
+    ///
+    /// Any pointer allocated by this allocator is guaranteed to be aligned to `MIN_ALIGN` even if
+    /// the requested layout has a smaller alignment.
+    const MIN_ALIGN: usize;
     /// Allocate memory based on `layout` and `flags`.
     ///
     /// On success, returns a buffer represented as `NonNull<[u8]>` that satisfies the layout

rust/kernel/alloc/allocator.rs+8−0

 use crate::bindings;
 use crate::pr_warn;
+const ARCH_KMALLOC_MINALIGN: usize = bindings::ARCH_KMALLOC_MINALIGN;
 /// The contiguous kernel allocator.
 ///
 /// `Kmalloc` is typically used for physically contiguous allocations up to page size, but also
 // - passing a pointer to a valid memory allocation is OK,
 // - `realloc` satisfies the guarantees, since `ReallocFunc::call` has the same.
 unsafe impl Allocator for Kmalloc {
+    const MIN_ALIGN: usize = ARCH_KMALLOC_MINALIGN;
     #[inline]
     unsafe fn realloc(
         ptr: Option<NonNull<u8>>,
 // - passing a pointer to a valid memory allocation is OK,
 // - `realloc` satisfies the guarantees, since `ReallocFunc::call` has the same.
 unsafe impl Allocator for Vmalloc {
+    const MIN_ALIGN: usize = kernel::page::PAGE_SIZE;
     #[inline]
     unsafe fn realloc(
         ptr: Option<NonNull<u8>>,
 // - passing a pointer to a valid memory allocation is OK,
 // - `realloc` satisfies the guarantees, since `ReallocFunc::call` has the same.
 unsafe impl Allocator for KVmalloc {
+    const MIN_ALIGN: usize = ARCH_KMALLOC_MINALIGN;
     #[inline]
     unsafe fn realloc(
         ptr: Option<NonNull<u8>>,

rust/kernel/alloc/allocator_test.rs+0−124

@@ -1,124 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0
2
3	//! So far the kernel's `Box` and `Vec` types can't be used by userspace test cases, since all users
4	//! of those types (e.g. `CString`) use kernel allocators for instantiation.
5	//!
6	//! In order to allow userspace test cases to make use of such types as well, implement the
7	//! `Cmalloc` allocator within the `allocator_test` module and type alias all kernel allocators to
8	//! `Cmalloc`. The `Cmalloc` allocator uses libc's `realloc()` function as allocator backend.
9
10	#![allow(missing_docs)]
11
12	use super::{flags::*, AllocError, Allocator, Flags};
13	use core::alloc::Layout;
14	use core::cmp;
15	use core::ptr;
16	use core::ptr::NonNull;
17
18	/// The userspace allocator based on libc.
19	pub struct Cmalloc;
20
21	pub type Kmalloc = Cmalloc;
22	pub type Vmalloc = Kmalloc;
23	pub type KVmalloc = Kmalloc;
24
25	impl Cmalloc {
26	/// Returns a [`Layout`] that makes [`Kmalloc`] fulfill the requested size and alignment of
27	/// `layout`.
28	pub fn aligned_layout(layout: Layout) -> Layout {
29	// Note that `layout.size()` (after padding) is guaranteed to be a multiple of
30	// `layout.align()` which together with the slab guarantees means that `Kmalloc` will return
31	// a properly aligned object (see comments in `kmalloc()` for more information).
32	layout.pad_to_align()
33	}
34	}
35
36	extern "C" {
37	#[link_name = "aligned_alloc"]
38	fn libc_aligned_alloc(align: usize, size: usize) -> *mut crate::ffi::c_void;
39
40	#[link_name = "free"]
41	fn libc_free(ptr: *mut crate::ffi::c_void);
42	}
43
44	// SAFETY:
45	// - memory remains valid until it is explicitly freed,
46	// - passing a pointer to a valid memory allocation created by this `Allocator` is always OK,
47	// - `realloc` provides the guarantees as provided in the `# Guarantees` section.
48	unsafe impl Allocator for Cmalloc {
49	unsafe fn realloc(
50	ptr: Option<NonNull<u8>>,
51	layout: Layout,
52	old_layout: Layout,
53	flags: Flags,
54	) -> Result<NonNull<[u8]>, AllocError> {
55	let src = match ptr {
56	Some(src) => {
57	if old_layout.size() == 0 {
58	ptr::null_mut()
59	} else {
60	src.as_ptr()
61	}
62	}
63	None => ptr::null_mut(),
64	};
65
66	if layout.size() == 0 {
67	// SAFETY: `src` is either NULL or was previously allocated with this `Allocator`
68	unsafe { libc_free(src.cast()) };
69
70	return Ok(NonNull::slice_from_raw_parts(
71	crate::alloc::dangling_from_layout(layout),
72	0,
73	));
74	}
75
76	// ISO C (ISO/IEC 9899:2011) defines `aligned_alloc`:
77	//
78	// > The value of alignment shall be a valid alignment supported by the implementation
79	// [...].
80	//
81	// As an example of the "supported by the implementation" requirement, POSIX.1-2001 (IEEE
82	// 1003.1-2001) defines `posix_memalign`:
83	//
84	// > The value of alignment shall be a power of two multiple of sizeof (void *).
85	//
86	// and POSIX-based implementations of `aligned_alloc` inherit this requirement. At the time
87	// of writing, this is known to be the case on macOS (but not in glibc).
88	//
89	// Satisfy the stricter requirement to avoid spurious test failures on some platforms.
90	let min_align = core::mem::size_of::<*const crate::ffi::c_void>();
91	let layout = layout.align_to(min_align).map_err(\|_\| AllocError)?;
92	let layout = layout.pad_to_align();
93
94	// SAFETY: Returns either NULL or a pointer to a memory allocation that satisfies or
95	// exceeds the given size and alignment requirements.
96	let dst = unsafe { libc_aligned_alloc(layout.align(), layout.size()) }.cast::<u8>();
97	let dst = NonNull::new(dst).ok_or(AllocError)?;
98
99	if flags.contains(__GFP_ZERO) {
100	// SAFETY: The preceding calls to `libc_aligned_alloc` and `NonNull::new`
101	// guarantee that `dst` points to memory of at least `layout.size()` bytes.
102	unsafe { dst.as_ptr().write_bytes(0, layout.size()) };
103	}
104
105	if !src.is_null() {
106	// SAFETY:
107	// - `src` has previously been allocated with this `Allocator`; `dst` has just been
108	// newly allocated, hence the memory regions do not overlap.
109	// - both` src` and `dst` are properly aligned and valid for reads and writes
110	unsafe {
111	ptr::copy_nonoverlapping(
112	src,
113	dst.as_ptr(),
114	cmp::min(layout.size(), old_layout.size()),
115	)
116	};
117	}
118
119	// SAFETY: `src` is either NULL or was previously allocated with this `Allocator`
120	unsafe { libc_free(src.cast()) };
121
122	Ok(NonNull::slice_from_raw_parts(dst, layout.size()))
123	}
124	}

rust/kernel/alloc/kbox.rs+87−5

@@ -7,7 +7,6 @@ use super::allocator::{KVmalloc, Kmalloc, Vmalloc}; · 6 unmodified lines
7	use super::{AllocError, Allocator, Flags};	7	use super::{AllocError, Allocator, Flags};
8	use core::alloc::Layout;	8	use core::alloc::Layout;
9	use core::borrow::{Borrow, BorrowMut};	9	use core::borrow::{Borrow, BorrowMut};
10	use core::fmt;
11	use core::marker::PhantomData;	10	use core::marker::PhantomData;
12	use core::mem::ManuallyDrop;	11	use core::mem::ManuallyDrop;
13	use core::mem::MaybeUninit;	12	use core::mem::MaybeUninit;
@@ -17,6 +16,7 @@ use core::ptr::NonNull; · 3 unmodified lines
17	use core::result::Result;	16	use core::result::Result;
18		17
19	use crate::ffi::c_void;	18	use crate::ffi::c_void;
		19	use crate::fmt;
20	use crate::init::InPlaceInit;	20	use crate::init::InPlaceInit;
21	use crate::types::ForeignOwnable;	21	use crate::types::ForeignOwnable;
22	use pin_init::{InPlaceWrite, Init, PinInit, ZeroableOption};	22	use pin_init::{InPlaceWrite, Init, PinInit, ZeroableOption};
@@ -290,6 +290,83 @@ where · 267 unmodified lines
290	Ok(Self::new(x, flags)?.into())	290	Ok(Self::new(x, flags)?.into())
291	}	291	}
292		292
		293	/// Construct a pinned slice of elements `Pin<Box<[T], A>>`.
		294	///
		295	/// This is a convenient means for creation of e.g. slices of structrures containing spinlocks
		296	/// or mutexes.
		297	///
		298	/// # Examples
		299	///
		300	/// ```
		301	/// use kernel::sync::{new_spinlock, SpinLock};
		302	///
		303	/// struct Inner {
		304	/// a: u32,
		305	/// b: u32,
		306	/// }
		307	///
		308	/// #[pin_data]
		309	/// struct Example {
		310	/// c: u32,
		311	/// #[pin]
		312	/// d: SpinLock<Inner>,
		313	/// }
		314	///
		315	/// impl Example {
		316	/// fn new() -> impl PinInit<Self, Error> {
		317	/// try_pin_init!(Self {
		318	/// c: 10,
		319	/// d <- new_spinlock!(Inner { a: 20, b: 30 }),
		320	/// })
		321	/// }
		322	/// }
		323	///
		324	/// // Allocate a boxed slice of 10 `Example`s.
		325	/// let s = KBox::pin_slice(
		326	/// \| _i \| Example::new(),
		327	/// 10,
		328	/// GFP_KERNEL
		329	/// )?;
		330	///
		331	/// assert_eq!(s[5].c, 10);
		332	/// assert_eq!(s[3].d.lock().a, 20);
		333	/// # Ok::<(), Error>(())
		334	/// ```
		335	pub fn pin_slice<Func, Item, E>(
		336	mut init: Func,
		337	len: usize,
		338	flags: Flags,
		339	) -> Result<Pin<Box<[T], A>>, E>
		340	where
		341	Func: FnMut(usize) -> Item,
		342	Item: PinInit<T, E>,
		343	E: From<AllocError>,
		344	{
		345	let mut buffer = super::Vec::<T, A>::with_capacity(len, flags)?;
		346	for i in 0..len {
		347	let ptr = buffer.spare_capacity_mut().as_mut_ptr().cast();
		348	// SAFETY:
		349	// - `ptr` is a valid pointer to uninitialized memory.
		350	// - `ptr` is not used if an error is returned.
		351	// - `ptr` won't be moved until it is dropped, i.e. it is pinned.
		352	unsafe { init(i).__pinned_init(ptr)? };
		353
		354	// SAFETY:
		355	// - `i + 1 <= len`, hence we don't exceed the capacity, due to the call to
		356	// `with_capacity()` above.
		357	// - The new value at index buffer.len() + 1 is the only element being added here, and
		358	// it has been initialized above by `init(i).__pinned_init(ptr)`.
		359	unsafe { buffer.inc_len(1) };
		360	}
		361
		362	let (ptr, _, _) = buffer.into_raw_parts();
		363	let slice = core::ptr::slice_from_raw_parts_mut(ptr, len);
		364
		365	// SAFETY: `slice` points to an allocation allocated with `A` (`buffer`) and holds a valid
		366	// `[T]`.
		367	Ok(Pin::from(unsafe { Box::from_raw(slice) }))
		368	}
		369
293	/// Convert a [`Box<T,A>`] to a [`Pin<Box<T,A>>`]. If `T` does not implement	370	/// Convert a [`Box<T,A>`] to a [`Pin<Box<T,A>>`]. If `T` does not implement
294	/// [`Unpin`], then `x` will be pinned in memory and can't be moved.	371	/// [`Unpin`], then `x` will be pinned in memory and can't be moved.
295	pub fn into_pin(this: Self) -> Pin<Self> {	372	pub fn into_pin(this: Self) -> Pin<Self> {
@@ -401,12 +478,17 @@ where · 105 unmodified lines
401	}	478	}
402		479
403	// SAFETY: The pointer returned by `into_foreign` comes from a well aligned	480	// SAFETY: The pointer returned by `into_foreign` comes from a well aligned
404	// pointer to `T`.	481	// pointer to `T` allocated by `A`.
405	unsafe impl<T: 'static, A> ForeignOwnable for Box<T, A>	482	unsafe impl<T: 'static, A> ForeignOwnable for Box<T, A>
406	where	483	where
407	A: Allocator,	484	A: Allocator,
408	{	485	{
409	const FOREIGN_ALIGN: usize = core::mem::align_of::<T>();	486	const FOREIGN_ALIGN: usize = if core::mem::align_of::<T>() < A::MIN_ALIGN {
		487	A::MIN_ALIGN
		488	} else {
		489	core::mem::align_of::<T>()
		490	};
		491
410	type Borrowed<'a> = &'a T;	492	type Borrowed<'a> = &'a T;
411	type BorrowedMut<'a> = &'a mut T;	493	type BorrowedMut<'a> = &'a mut T;
412		494
@@ -435,12 +517,12 @@ where · 22 unmodified lines
435	}	517	}
436		518
437	// SAFETY: The pointer returned by `into_foreign` comes from a well aligned	519	// SAFETY: The pointer returned by `into_foreign` comes from a well aligned
438	// pointer to `T`.	520	// pointer to `T` allocated by `A`.
439	unsafe impl<T: 'static, A> ForeignOwnable for Pin<Box<T, A>>	521	unsafe impl<T: 'static, A> ForeignOwnable for Pin<Box<T, A>>
440	where	522	where
441	A: Allocator,	523	A: Allocator,
442	{	524	{
443	const FOREIGN_ALIGN: usize = core::mem::align_of::<T>();	525	const FOREIGN_ALIGN: usize = <Box<T, A> as ForeignOwnable>::FOREIGN_ALIGN;
444	type Borrowed<'a> = Pin<&'a T>;	526	type Borrowed<'a> = Pin<&'a T>;
445	type BorrowedMut<'a> = Pin<&'a mut T>;	527	type BorrowedMut<'a> = Pin<&'a mut T>;
446		528

rust/kernel/alloc/kvec.rs+17−7

     layout::ArrayLayout,
     AllocError, Allocator, Box, Flags,
 };
+use crate::fmt;
 use core::{
     borrow::{Borrow, BorrowMut},
-    fmt,
     marker::PhantomData,
     mem::{ManuallyDrop, MaybeUninit},
     ops::Deref,
     /// Returns the number of elements that can be stored within the vector without allocating
     /// additional memory.
-    pub fn capacity(&self) -> usize {
+    pub const fn capacity(&self) -> usize {
         if const { Self::is_zst() } {
             usize::MAX
         } else {
     /// Returns the number of elements stored within the vector.
     #[inline]
-    pub fn len(&self) -> usize {
+    pub const fn len(&self) -> usize {
         self.len
     }
     /// - `additional` must be less than or equal to `self.capacity - self.len`.
     /// - All elements within the interval [`self.len`,`self.len + additional`) must be initialized.
     #[inline]
-    pub unsafe fn inc_len(&mut self, additional: usize) {
+    pub const unsafe fn inc_len(&mut self, additional: usize) {
         // Guaranteed by the type invariant to never underflow.
         debug_assert!(additional <= self.capacity() - self.len());
         // INVARIANT: By the safety requirements of this method this represents the exact number of
     }
     /// Returns a slice of the entire vector.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut v = KVec::new();
+    /// v.push(1, GFP_KERNEL)?;
+    /// v.push(2, GFP_KERNEL)?;
+    /// assert_eq!(v.as_slice(), &[1, 2]);
+    /// # Ok::<(), Error>(())
+    /// ```
     #[inline]
     pub fn as_slice(&self) -> &[T] {
         self
     /// Returns a raw pointer to the vector's backing buffer, or, if `T` is a ZST, a dangling raw
     /// pointer.
     #[inline]
-    pub fn as_ptr(&self) -> *const T {
+    pub const fn as_ptr(&self) -> *const T {
         self.ptr.as_ptr()
     }
     /// assert!(!v.is_empty());
     /// ```
     #[inline]
-    pub fn is_empty(&self) -> bool {
+    pub const fn is_empty(&self) -> bool {
         self.len() == 0
     }
     }
 }
-#[macros::kunit_tests(rust_kvec_kunit)]
+#[macros::kunit_tests(rust_kvec)]
 mod tests {
     use super::*;
     use crate::prelude::*;

rust/kernel/alloc/kvec/errors.rs+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	//! Errors for the [`Vec`] type.	3	//! Errors for the [`Vec`] type.
4		4
5	use core::fmt::{self, Debug, Formatter};	5	use kernel::fmt::{self, Debug, Formatter};
6	use kernel::prelude::*;	6	use kernel::prelude::*;
7		7
8	/// Error type for [`Vec::push_within_capacity`].	8	/// Error type for [`Vec::push_within_capacity`].

rust/kernel/alloc/layout.rs+1−1

@@ -80,7 +80,7 @@ impl<T> ArrayLayout<T> { · 79 unmodified lines
80	/// # Safety	80	/// # Safety
81	///	81	///
82	/// `len` must be a value, for which `len * size_of::<T>() <= isize::MAX` is true.	82	/// `len` must be a value, for which `len * size_of::<T>() <= isize::MAX` is true.
83	pub unsafe fn new_unchecked(len: usize) -> Self {	83	pub const unsafe fn new_unchecked(len: usize) -> Self {
84	// INVARIANT: By the safety requirements of this function	84	// INVARIANT: By the safety requirements of this function
85	// `len * size_of::<T>() <= isize::MAX`.	85	// `len * size_of::<T>() <= isize::MAX`.
86	Self {	86	Self {

rust/kernel/auxiliary.rs+2−2

@@ -105,8 +105,8 @@ pub struct DeviceId(bindings::auxiliary_device_id); · 104 unmodified lines
105	impl DeviceId {	105	impl DeviceId {
106	/// Create a new [`DeviceId`] from name.	106	/// Create a new [`DeviceId`] from name.
107	pub const fn new(modname: &'static CStr, name: &'static CStr) -> Self {	107	pub const fn new(modname: &'static CStr, name: &'static CStr) -> Self {
108	let name = name.as_bytes_with_nul();	108	let name = name.to_bytes_with_nul();
109	let modname = modname.as_bytes_with_nul();	109	let modname = modname.to_bytes_with_nul();
110		110
111	// TODO: Replace with `bindings::auxiliary_device_id::default()` once stabilized for	111	// TODO: Replace with `bindings::auxiliary_device_id::default()` once stabilized for
112	// `const`.	112	// `const`.

rust/kernel/block/mq.rs+1−1

@@ -82,7 +82,7 @@ · 81 unmodified lines
82	//! Arc::pin_init(TagSet::new(1, 256, 1), flags::GFP_KERNEL)?;	82	//! Arc::pin_init(TagSet::new(1, 256, 1), flags::GFP_KERNEL)?;
83	//! let mut disk = gen_disk::GenDiskBuilder::new()	83	//! let mut disk = gen_disk::GenDiskBuilder::new()
84	//! .capacity_sectors(4096)	84	//! .capacity_sectors(4096)
85	//! .build(format_args!("myblk"), tagset)?;	85	//! .build(fmt!("myblk"), tagset)?;
86	//!	86	//!
87	//! # Ok::<(), kernel::error::Error>(())	87	//! # Ok::<(), kernel::error::Error>(())
88	//! ```	88	//! ```

rust/kernel/block/mq/gen_disk.rs+2−2

 //! Generic disk abstraction.
 //!
 //! C header: [`include/linux/blkdev.h`](srctree/include/linux/blkdev.h)
-//! C header: [`include/linux/blk_mq.h`](srctree/include/linux/blk_mq.h)
+//! C header: [`include/linux/blk-mq.h`](srctree/include/linux/blk-mq.h)
 use crate::block::mq::{raw_writer::RawWriter, Operations, TagSet};
+use crate::fmt::{self, Write};
 use crate::{bindings, error::from_err_ptr, error::Result, sync::Arc};
 use crate::{error, static_lock_class};
-use core::fmt::{self, Write};
 /// A builder for [`GenDisk`].
 ///

rust/kernel/block/mq/raw_writer.rs+1−2

@@ -1,8 +1,7 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2		2
3	use core::fmt::{self, Write};
4
5	use crate::error::Result;	3	use crate::error::Result;
		4	use crate::fmt::{self, Write};
6	use crate::prelude::EINVAL;	5	use crate::prelude::EINVAL;
7		6
8	/// A mutable reference to a byte buffer where a string can be written into.	7	/// A mutable reference to a byte buffer where a string can be written into.

rust/kernel/configfs.rs+2−2

@@ -263,7 +263,7 @@ impl<Data> Group<Data> { · 262 unmodified lines
263	try_pin_init!(Self {	263	try_pin_init!(Self {
264	group <- pin_init::init_zeroed().chain(\|v: &mut Opaque<bindings::config_group>\| {	264	group <- pin_init::init_zeroed().chain(\|v: &mut Opaque<bindings::config_group>\| {
265	let place = v.get();	265	let place = v.get();
266	let name = name.as_bytes_with_nul().as_ptr();	266	let name = name.to_bytes_with_nul().as_ptr();
267	// SAFETY: It is safe to initialize a group once it has been zeroed.	267	// SAFETY: It is safe to initialize a group once it has been zeroed.
268	unsafe {	268	unsafe {
269	bindings::config_group_init_type_name(place, name.cast(), item_type.as_ptr())	269	bindings::config_group_init_type_name(place, name.cast(), item_type.as_ptr())
@@ -613,7 +613,7 @@ where · 343 unmodified lines
613	pub const fn new(name: &'static CStr) -> Self {	613	pub const fn new(name: &'static CStr) -> Self {
614	Self {	614	Self {
615	attribute: Opaque::new(bindings::configfs_attribute {	615	attribute: Opaque::new(bindings::configfs_attribute {
616	ca_name: name.as_char_ptr(),	616	ca_name: crate::str::as_char_ptr_in_const_context(name),
617	ca_owner: core::ptr::null_mut(),	617	ca_owner: core::ptr::null_mut(),
618	ca_mode: 0o660,	618	ca_mode: 0o660,
619	show: Some(Self::show),	619	show: Some(Self::show),

rust/kernel/cpu.rs+1−0

@@ -109,6 +109,7 @@ impl CpuId { · 108 unmodified lines
109	/// unexpectedly due to preemption or CPU migration. It should only be	109	/// unexpectedly due to preemption or CPU migration. It should only be
110	/// used when the context ensures that the task remains on the same CPU	110	/// used when the context ensures that the task remains on the same CPU
111	/// or the users could use a stale (yet valid) CPU ID.	111	/// or the users could use a stale (yet valid) CPU ID.
		112	#[inline]
112	pub fn current() -> Self {	113	pub fn current() -> Self {
113	// SAFETY: raw_smp_processor_id() always returns a valid CPU ID.	114	// SAFETY: raw_smp_processor_id() always returns a valid CPU ID.
114	unsafe { Self::from_u32_unchecked(bindings::raw_smp_processor_id()) }	115	unsafe { Self::from_u32_unchecked(bindings::raw_smp_processor_id()) }

rust/kernel/cpufreq.rs+2−4

 use core::{
     cell::UnsafeCell,
     marker::PhantomData,
-    mem::MaybeUninit,
     ops::{Deref, DerefMut},
     pin::Pin,
     ptr,
         } else {
             None
         },
-        // SAFETY: All zeros is a valid value for `bindings::cpufreq_driver`.
+        ..pin_init::zeroed()
-        ..unsafe { MaybeUninit::zeroed().assume_init() }
     };
     const fn copy_name(name: &'static CStr) -> [c_char; CPUFREQ_NAME_LEN] {
-        let src = name.as_bytes_with_nul();
+        let src = name.to_bytes_with_nul();
         let mut dst = [0; CPUFREQ_NAME_LEN];
         build_assert!(src.len() <= CPUFREQ_NAME_LEN);

rust/kernel/device.rs+3−3

@@ -5,10 +5,10 @@ · 4 unmodified lines
5	//! C header: [`include/linux/device.h`](srctree/include/linux/device.h)	5	//! C header: [`include/linux/device.h`](srctree/include/linux/device.h)
6		6
7	use crate::{	7	use crate::{
8	bindings,	8	bindings, fmt,
9	types::{ARef, ForeignOwnable, Opaque},	9	types::{ARef, ForeignOwnable, Opaque},
10	};	10	};
11	use core::{fmt, marker::PhantomData, ptr};	11	use core::{marker::PhantomData, ptr};
12		12
13	#[cfg(CONFIG_PRINTK)]	13	#[cfg(CONFIG_PRINTK)]
14	use crate::c_str;	14	use crate::c_str;
@@ -596,7 +596,7 @@ macro_rules! impl_device_context_into_aref { · 581 unmodified lines
596	macro_rules! dev_printk {	596	macro_rules! dev_printk {
597	($method:ident, $dev:expr, $($f:tt)*) => {	597	($method:ident, $dev:expr, $($f:tt)*) => {
598	{	598	{
599	($dev).$method(::core::format_args!($($f)*));	599	($dev).$method($crate::prelude::fmt!($($f)*));
600	}	600	}
601	}	601	}
602	}	602	}

rust/kernel/device/property.rs+12−11

     alloc::KVec,
     bindings,
     error::{to_result, Result},
+    fmt,
     prelude::*,
     str::{CStr, CString},
     types::{ARef, Opaque},
         unsafe { bindings::is_of_node(self.as_raw()) }
     }
-    /// Returns an object that implements [`Display`](core::fmt::Display) for
+    /// Returns an object that implements [`Display`](fmt::Display) for
     /// printing the name of a node.
     ///
     /// This is an alternative to the default `Display` implementation, which
     /// prints the full path.
-    pub fn display_name(&self) -> impl core::fmt::Display + '_ {
+    pub fn display_name(&self) -> impl fmt::Display + '_ {
         struct FwNodeDisplayName<'a>(&'a FwNode);
-        impl core::fmt::Display for FwNodeDisplayName<'_> {
+        impl fmt::Display for FwNodeDisplayName<'_> {
-            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 // SAFETY: `self` is valid by its type invariant.
                 let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
                 if name.is_null() {
                 // - `fwnode_get_name` returns null or a valid C string.
                 // - `name` was checked to be non-null.
                 let name = unsafe { CStr::from_char_ptr(name) };
-                write!(f, "{name}")
+                fmt::Display::fmt(name, f)
             }
         }
     }
 }
-impl core::fmt::Debug for FwNodeReferenceArgs {
+impl fmt::Debug for FwNodeReferenceArgs {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}", self.as_slice())
     }
 }
     Owned(ARef<FwNode>),
 }
-impl core::fmt::Display for FwNode {
+impl fmt::Display for FwNode {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // The logic here is the same as the one in lib/vsprintf.c
         // (fwnode_full_name_string).
                 // SAFETY: `fwnode_get_name_prefix` returns null or a
                 // valid C string.
                 let prefix = unsafe { CStr::from_char_ptr(prefix) };
-                write!(f, "{prefix}")?;
+                fmt::Display::fmt(prefix, f)?;
             }
-            write!(f, "{}", fwnode.display_name())?;
+            fmt::Display::fmt(&fwnode.display_name(), f)?;
         }
         Ok(())

rust/kernel/dma.rs+1−1

     device::{Bound, Core},
     error::{to_result, Result},
     prelude::*,
+    sync::aref::ARef,
     transmute::{AsBytes, FromBytes},
-    types::ARef,
 };
 /// Trait to be implemented by DMA capable bus devices.

rust/kernel/drm/device.rs+3−3

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	//! DRM device.	3	//! DRM device.
4	//!	4	//!
5	//! C header: [`include/linux/drm/drm_device.h`](srctree/include/linux/drm/drm_device.h)	5	//! C header: [`include/drm/drm_device.h`](srctree/include/drm/drm_device.h)
6		6
7	use crate::{	7	use crate::{
8	alloc::allocator::Kmalloc,	8	alloc::allocator::Kmalloc,
@@ -82,8 +82,8 @@ impl<T: drm::Driver> Device<T> { · 73 unmodified lines
82	major: T::INFO.major,	82	major: T::INFO.major,
83	minor: T::INFO.minor,	83	minor: T::INFO.minor,
84	patchlevel: T::INFO.patchlevel,	84	patchlevel: T::INFO.patchlevel,
85	name: T::INFO.name.as_char_ptr().cast_mut(),	85	name: crate::str::as_char_ptr_in_const_context(T::INFO.name).cast_mut(),
86	desc: T::INFO.desc.as_char_ptr().cast_mut(),	86	desc: crate::str::as_char_ptr_in_const_context(T::INFO.desc).cast_mut(),
87		87
88	driver_features: drm::driver::FEAT_GEM,	88	driver_features: drm::driver::FEAT_GEM,
89	ioctls: T::IOCTLS.as_ptr(),	89	ioctls: T::IOCTLS.as_ptr(),

rust/kernel/drm/driver.rs+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	//! DRM driver core.	3	//! DRM driver core.
4	//!	4	//!
5	//! C header: [`include/linux/drm/drm_drv.h`](srctree/include/linux/drm/drm_drv.h)	5	//! C header: [`include/drm/drm_drv.h`](srctree/include/drm/drm_drv.h)
6		6
7	use crate::{	7	use crate::{
8	bindings, device, devres, drm,	8	bindings, device, devres, drm,

rust/kernel/drm/file.rs+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	//! DRM File objects.	3	//! DRM File objects.
4	//!	4	//!
5	//! C header: [`include/linux/drm/drm_file.h`](srctree/include/linux/drm/drm_file.h)	5	//! C header: [`include/drm/drm_file.h`](srctree/include/drm/drm_file.h)
6		6
7	use crate::{bindings, drm, error::Result, prelude::*, types::Opaque};	7	use crate::{bindings, drm, error::Result, prelude::*, types::Opaque};
8	use core::marker::PhantomData;	8	use core::marker::PhantomData;

rust/kernel/drm/gem/mod.rs+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	//! DRM GEM API	3	//! DRM GEM API
4	//!	4	//!
5	//! C header: [`include/linux/drm/drm_gem.h`](srctree/include/linux/drm/drm_gem.h)	5	//! C header: [`include/drm/drm_gem.h`](srctree/include/drm/drm_gem.h)
6		6
7	use crate::{	7	use crate::{
8	alloc::flags::*,	8	alloc::flags::*,

rust/kernel/drm/ioctl.rs+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	//! DRM IOCTL definitions.	3	//! DRM IOCTL definitions.
4	//!	4	//!
5	//! C header: [`include/linux/drm/drm_ioctl.h`](srctree/include/linux/drm/drm_ioctl.h)	5	//! C header: [`include/drm/drm_ioctl.h`](srctree/include/drm/drm_ioctl.h)
6		6
7	use crate::ioctl;	7	use crate::ioctl;
8		8

rust/kernel/error.rs+59−7

@@ -2,7 +2,9 @@ · 1 unmodified line
2		2
3	//! Kernel errors.	3	//! Kernel errors.
4	//!	4	//!
5	//! C header: [`include/uapi/asm-generic/errno-base.h`](srctree/include/uapi/asm-generic/errno-base.h)	5	//! C header: [`include/uapi/asm-generic/errno-base.h`](srctree/include/uapi/asm-generic/errno-base.h)\
		6	//! C header: [`include/uapi/asm-generic/errno.h`](srctree/include/uapi/asm-generic/errno.h)\
		7	//! C header: [`include/linux/errno.h`](srctree/include/linux/errno.h)
6		8
7	use crate::{	9	use crate::{
8	alloc::{layout::LayoutError, AllocError},	10	alloc::{layout::LayoutError, AllocError},
@@ -101,8 +103,23 @@ pub struct Error(NonZeroI32); · 92 unmodified lines
101	impl Error {	103	impl Error {
102	/// Creates an [`Error`] from a kernel error code.	104	/// Creates an [`Error`] from a kernel error code.
103	///	105	///
104	/// It is a bug to pass an out-of-range `errno`. `EINVAL` would	106	/// `errno` must be within error code range (i.e. `>= -MAX_ERRNO && < 0`).
105	/// be returned in such a case.	107	///
		108	/// It is a bug to pass an out-of-range `errno`. [`code::EINVAL`] is returned in such a case.
		109	///
		110	/// # Examples
		111	///
		112	/// ```
		113	/// assert_eq!(Error::from_errno(-1), EPERM);
		114	/// assert_eq!(Error::from_errno(-2), ENOENT);
		115	/// ```
		116	///
		117	/// The following calls are considered a bug:
		118	///
		119	/// ```
		120	/// assert_eq!(Error::from_errno(0), EINVAL);
		121	/// assert_eq!(Error::from_errno(-1000000), EINVAL);
		122	/// ```
106	pub fn from_errno(errno: crate::ffi::c_int) -> Error {	123	pub fn from_errno(errno: crate::ffi::c_int) -> Error {
107	if let Some(error) = Self::try_from_errno(errno) {	124	if let Some(error) = Self::try_from_errno(errno) {
108	error	125	error
@@ -158,7 +175,7 @@ impl Error { · 49 unmodified lines
158	}	175	}
159		176
160	/// Returns a string representing the error, if one exists.	177	/// Returns a string representing the error, if one exists.
161	#[cfg(not(any(test, testlib)))]	178	#[cfg(not(testlib))]
162	pub fn name(&self) -> Option<&'static CStr> {	179	pub fn name(&self) -> Option<&'static CStr> {
163	// SAFETY: Just an FFI call, there are no extra safety requirements.	180	// SAFETY: Just an FFI call, there are no extra safety requirements.
164	let ptr = unsafe { bindings::errname(-self.0.get()) };	181	let ptr = unsafe { bindings::errname(-self.0.get()) };
@@ -175,7 +192,7 @@ impl Error { · 10 unmodified lines
175	/// When `testlib` is configured, this always returns `None` to avoid the dependency on a	192	/// When `testlib` is configured, this always returns `None` to avoid the dependency on a
176	/// kernel function so that tests that use this (e.g., by calling [`Result::unwrap`]) can still	193	/// kernel function so that tests that use this (e.g., by calling [`Result::unwrap`]) can still
177	/// run in userspace.	194	/// run in userspace.
178	#[cfg(any(test, testlib))]	195	#[cfg(testlib)]
179	pub fn name(&self) -> Option<&'static CStr> {	196	pub fn name(&self) -> Option<&'static CStr> {
180	None	197	None
181	}	198	}
@@ -375,8 +392,43 @@ impl From<core::convert::Infallible> for Error { · 193 unmodified lines
375	/// [Rust documentation]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html	392	/// [Rust documentation]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html
376	pub type Result<T = (), E = Error> = core::result::Result<T, E>;	393	pub type Result<T = (), E = Error> = core::result::Result<T, E>;
377		394
378	/// Converts an integer as returned by a C kernel function to an error if it's negative, and	395	/// Converts an integer as returned by a C kernel function to a [`Result`].
379	/// `Ok(())` otherwise.	396	///
		397	/// If the integer is negative, an [`Err`] with an [`Error`] as given by [`Error::from_errno`] is
		398	/// returned. This means the integer must be `>= -MAX_ERRNO`.
		399	///
		400	/// Otherwise, it returns [`Ok`].
		401	///
		402	/// It is a bug to pass an out-of-range negative integer. `Err(EINVAL)` is returned in such a case.
		403	///
		404	/// # Examples
		405	///
		406	/// This function may be used to easily perform early returns with the [`?`] operator when working
		407	/// with C APIs within Rust abstractions:
		408	///
		409	/// ```
		410	/// # use kernel::error::to_result;
		411	/// # mod bindings {
		412	/// # #![expect(clippy::missing_safety_doc)]
		413	/// # use kernel::prelude::*;
		414	/// # pub(super) unsafe fn f1() -> c_int { 0 }
		415	/// # pub(super) unsafe fn f2() -> c_int { EINVAL.to_errno() }
		416	/// # }
		417	/// fn f() -> Result {
		418	/// // SAFETY: ...
		419	/// to_result(unsafe { bindings::f1() })?;
		420	///
		421	/// // SAFETY: ...
		422	/// to_result(unsafe { bindings::f2() })?;
		423	///
		424	/// // ...
		425	///
		426	/// Ok(())
		427	/// }
		428	/// # assert_eq!(f(), Err(EINVAL));
		429	/// ```
		430	///
		431	/// [`?`]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator
380	pub fn to_result(err: crate::ffi::c_int) -> Result {	432	pub fn to_result(err: crate::ffi::c_int) -> Result {
381	if err < 0 {	433	if err < 0 {
382	Err(Error::from_errno(err))	434	Err(Error::from_errno(err))

rust/kernel/firmware.rs+1−1

@@ -291,7 +291,7 @@ impl<const N: usize> ModInfoBuilder<N> { · 290 unmodified lines
291	let module_name = this.module_name;	291	let module_name = this.module_name;
292		292
293	if !this.module_name.is_empty() {	293	if !this.module_name.is_empty() {
294	this = this.push_internal(module_name.as_bytes_with_nul());	294	this = this.push_internal(module_name.to_bytes_with_nul());
295		295
296	if N != 0 {	296	if N != 0 {
297	// Re-use the space taken by the NULL terminator and swap it with the '.' separator.	297	// Re-use the space taken by the NULL terminator and swap it with the '.' separator.

rust/kernel/fs/file.rs+3−2

     bindings,
     cred::Credential,
     error::{code::*, to_result, Error, Result},
+    fmt,
     sync::aref::{ARef, AlwaysRefCounted},
     types::{NotThreadSafe, Opaque},
 };
     }
 }
-impl core::fmt::Debug for BadFdError {
+impl fmt::Debug for BadFdError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("EBADF")
     }
 }

rust/kernel/kunit.rs+7−7

 //!
 //! Reference: <https://docs.kernel.org/dev-tools/kunit/index.html>
+use crate::fmt;
 use crate::prelude::*;
-use core::fmt;
 #[cfg(CONFIG_PRINTK)]
 use crate::c_str;
                 // mistake (it is hidden to prevent that).
                 //
                 // This mimics KUnit's failed assertion format.
-                $crate::kunit::err(format_args!(
+                $crate::kunit::err($crate::prelude::fmt!(
                     "    # {}: ASSERTION FAILED at {FILE}:{LINE}\n",
                     $name
                 ));
-                $crate::kunit::err(format_args!(
+                $crate::kunit::err($crate::prelude::fmt!(
                     "    Expected {CONDITION} to be true, but is false\n"
                 ));
-                $crate::kunit::err(format_args!(
+                $crate::kunit::err($crate::prelude::fmt!(
                     "    Failure not reported to KUnit since this is a non-KUnit task\n"
                 ));
                 break 'out;
             unsafe impl Sync for UnaryAssert {}
             static LOCATION: Location = Location($crate::bindings::kunit_loc {
-                file: FILE.as_char_ptr(),
+                file: $crate::str::as_char_ptr_in_const_context(FILE),
                 line: LINE,
             });
             static ASSERTION: UnaryAssert = UnaryAssert($crate::bindings::kunit_unary_assert {
                 assert: $crate::bindings::kunit_assert {},
-                condition: CONDITION.as_char_ptr(),
+                condition: $crate::str::as_char_ptr_in_const_context(CONDITION),
                 expected_true: true,
             });
 ) -> kernel::bindings::kunit_case {
     kernel::bindings::kunit_case {
         run_case: Some(run_case),
-        name: name.as_char_ptr(),
+        name: kernel::str::as_char_ptr_in_const_context(name),
         attr: kernel::bindings::kunit_attributes {
             speed: kernel::bindings::kunit_speed_KUNIT_SPEED_NORMAL,
         },

rust/kernel/lib.rs+4−1

 // the unstable features in use.
 //
 // Stable since Rust 1.79.0.
+#![feature(generic_nonzero)]
 #![feature(inline_const)]
 //
 // Stable since Rust 1.81.0.
 // Stable since Rust 1.83.0.
 #![feature(const_maybe_uninit_as_mut_ptr)]
 #![feature(const_mut_refs)]
+#![feature(const_option)]
 #![feature(const_ptr_write)]
 #![feature(const_refs_to_cell)]
 //
 pub mod platform;
 pub mod prelude;
 pub mod print;
+pub mod ptr;
 pub mod rbtree;
 pub mod regulator;
 pub mod revocable;
     }
 }
-#[cfg(not(any(testlib, test)))]
+#[cfg(not(testlib))]
 #[panic_handler]
 fn panic(info: &core::panic::PanicInfo<'_>) -> ! {
     pr_emerg!("{}\n", info);

rust/kernel/list.rs+120−0

@@ -38,6 +38,8 @@ pub use self::arc_field::{define_list_arc_field_getter, ListArcField}; · 37 unmodified lines
38	///	38	///
39	/// # Examples	39	/// # Examples
40	///	40	///
		41	/// Use [`ListLinks`] as the type of the intrusive field.
		42	///
41	/// ```	43	/// ```
42	/// use kernel::list::*;	44	/// use kernel::list::*;
43	///	45	///
@@ -140,6 +142,124 @@ pub use self::arc_field::{define_list_arc_field_getter, ListArcField}; · 96 unmodified lines
140	/// }	142	/// }
141	/// # Result::<(), Error>::Ok(())	143	/// # Result::<(), Error>::Ok(())
142	/// ```	144	/// ```
		145	///
		146	/// Use [`ListLinksSelfPtr`] as the type of the intrusive field. This allows a list of trait object
		147	/// type.
		148	///
		149	/// ```
		150	/// use kernel::list::*;
		151	///
		152	/// trait Foo {
		153	/// fn foo(&self) -> (&'static str, i32);
		154	/// }
		155	///
		156	/// #[pin_data]
		157	/// struct DTWrap<T: ?Sized> {
		158	/// #[pin]
		159	/// links: ListLinksSelfPtr<DTWrap<dyn Foo>>,
		160	/// value: T,
		161	/// }
		162	///
		163	/// impl<T> DTWrap<T> {
		164	/// fn new(value: T) -> Result<ListArc<Self>> {
		165	/// ListArc::pin_init(try_pin_init!(Self {
		166	/// value,
		167	/// links <- ListLinksSelfPtr::new(),
		168	/// }), GFP_KERNEL)
		169	/// }
		170	/// }
		171	///
		172	/// impl_list_arc_safe! {
		173	/// impl{T: ?Sized} ListArcSafe<0> for DTWrap<T> { untracked; }
		174	/// }
		175	/// impl_list_item! {
		176	/// impl ListItem<0> for DTWrap<dyn Foo> { using ListLinksSelfPtr { self.links }; }
		177	/// }
		178	///
		179	/// // Create a new empty list.
		180	/// let mut list = List::<DTWrap<dyn Foo>>::new();
		181	/// {
		182	/// assert!(list.is_empty());
		183	/// }
		184	///
		185	/// struct A(i32);
		186	/// // `A` returns the inner value for `foo`.
		187	/// impl Foo for A { fn foo(&self) -> (&'static str, i32) { ("a", self.0) } }
		188	///
		189	/// struct B;
		190	/// // `B` always returns 42.
		191	/// impl Foo for B { fn foo(&self) -> (&'static str, i32) { ("b", 42) } }
		192	///
		193	/// // Insert 3 element using `push_back()`.
		194	/// list.push_back(DTWrap::new(A(15))?);
		195	/// list.push_back(DTWrap::new(A(32))?);
		196	/// list.push_back(DTWrap::new(B)?);
		197	///
		198	/// // Iterate over the list to verify the nodes were inserted correctly.
		199	/// // [A(15), A(32), B]
		200	/// {
		201	/// let mut iter = list.iter();
		202	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("a", 15));
		203	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("a", 32));
		204	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("b", 42));
		205	/// assert!(iter.next().is_none());
		206	///
		207	/// // Verify the length of the list.
		208	/// assert_eq!(list.iter().count(), 3);
		209	/// }
		210	///
		211	/// // Pop the items from the list using `pop_back()` and verify the content.
		212	/// {
		213	/// assert_eq!(list.pop_back().ok_or(EINVAL)?.value.foo(), ("b", 42));
		214	/// assert_eq!(list.pop_back().ok_or(EINVAL)?.value.foo(), ("a", 32));
		215	/// assert_eq!(list.pop_back().ok_or(EINVAL)?.value.foo(), ("a", 15));
		216	/// }
		217	///
		218	/// // Insert 3 elements using `push_front()`.
		219	/// list.push_front(DTWrap::new(A(15))?);
		220	/// list.push_front(DTWrap::new(A(32))?);
		221	/// list.push_front(DTWrap::new(B)?);
		222	///
		223	/// // Iterate over the list to verify the nodes were inserted correctly.
		224	/// // [B, A(32), A(15)]
		225	/// {
		226	/// let mut iter = list.iter();
		227	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("b", 42));
		228	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("a", 32));
		229	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("a", 15));
		230	/// assert!(iter.next().is_none());
		231	///
		232	/// // Verify the length of the list.
		233	/// assert_eq!(list.iter().count(), 3);
		234	/// }
		235	///
		236	/// // Pop the items from the list using `pop_front()` and verify the content.
		237	/// {
		238	/// assert_eq!(list.pop_back().ok_or(EINVAL)?.value.foo(), ("a", 15));
		239	/// assert_eq!(list.pop_back().ok_or(EINVAL)?.value.foo(), ("a", 32));
		240	/// }
		241	///
		242	/// // Push `list2` to `list` through `push_all_back()`.
		243	/// // list: [B]
		244	/// // list2: [B, A(25)]
		245	/// {
		246	/// let mut list2 = List::<DTWrap<dyn Foo>>::new();
		247	/// list2.push_back(DTWrap::new(B)?);
		248	/// list2.push_back(DTWrap::new(A(25))?);
		249	///
		250	/// list.push_all_back(&mut list2);
		251	///
		252	/// // list: [B, B, A(25)]
		253	/// // list2: []
		254	/// let mut iter = list.iter();
		255	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("b", 42));
		256	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("b", 42));
		257	/// assert_eq!(iter.next().ok_or(EINVAL)?.value.foo(), ("a", 25));
		258	/// assert!(iter.next().is_none());
		259	/// assert!(list2.is_empty());
		260	/// }
		261	/// # Result::<(), Error>::Ok(())
		262	/// ```
143	pub struct List<T: ?Sized + ListItem<ID>, const ID: u64 = 0> {	263	pub struct List<T: ?Sized + ListItem<ID>, const ID: u64 = 0> {
144	first: *mut ListLinksFields,	264	first: *mut ListLinksFields,
145	_ty: PhantomData<ListArc<T, ID>>,	265	_ty: PhantomData<ListArc<T, ID>>,

rust/kernel/miscdevice.rs+1−1

@@ -34,7 +34,7 @@ impl MiscDeviceOptions { · 33 unmodified lines
34	// SAFETY: All zeros is valid for this C type.	34	// SAFETY: All zeros is valid for this C type.
35	let mut result: bindings::miscdevice = unsafe { MaybeUninit::zeroed().assume_init() };	35	let mut result: bindings::miscdevice = unsafe { MaybeUninit::zeroed().assume_init() };
36	result.minor = bindings::MISC_DYNAMIC_MINOR as ffi::c_int;	36	result.minor = bindings::MISC_DYNAMIC_MINOR as ffi::c_int;
37	result.name = self.name.as_char_ptr();	37	result.name = crate::str::as_char_ptr_in_const_context(self.name);
38	result.fops = MiscdeviceVTable::<T>::build();	38	result.fops = MiscdeviceVTable::<T>::build();
39	result	39	result
40	}	40	}

rust/kernel/net/phy.rs+1−1

@@ -497,7 +497,7 @@ unsafe impl Sync for DriverVTable {} · 496 unmodified lines
497	pub const fn create_phy_driver<T: Driver>() -> DriverVTable {	497	pub const fn create_phy_driver<T: Driver>() -> DriverVTable {
498	// INVARIANT: All the fields of `struct phy_driver` are initialized properly.	498	// INVARIANT: All the fields of `struct phy_driver` are initialized properly.
499	DriverVTable(Opaque::new(bindings::phy_driver {	499	DriverVTable(Opaque::new(bindings::phy_driver {
500	name: T::NAME.as_char_ptr().cast_mut(),	500	name: crate::str::as_char_ptr_in_const_context(T::NAME).cast_mut(),
501	flags: T::FLAGS,	501	flags: T::FLAGS,
502	phy_id: T::PHY_DEVICE_ID.id(),	502	phy_id: T::PHY_DEVICE_ID.id(),
503	phy_id_mask: T::PHY_DEVICE_ID.mask_as_int(),	503	phy_id_mask: T::PHY_DEVICE_ID.mask_as_int(),

rust/kernel/of.rs+1−1

@@ -34,7 +34,7 @@ unsafe impl RawDeviceIdIndex for DeviceId { · 33 unmodified lines
34	impl DeviceId {	34	impl DeviceId {
35	/// Create a new device id from an OF 'compatible' string.	35	/// Create a new device id from an OF 'compatible' string.
36	pub const fn new(compatible: &'static CStr) -> Self {	36	pub const fn new(compatible: &'static CStr) -> Self {
37	let src = compatible.as_bytes_with_nul();	37	let src = compatible.to_bytes_with_nul();
38	// Replace with `bindings::of_device_id::default()` once stabilized for `const`.	38	// Replace with `bindings::of_device_id::default()` once stabilized for `const`.
39	// SAFETY: FFI type is valid to be zero-initialized.	39	// SAFETY: FFI type is valid to be zero-initialized.
40	let mut of: bindings::of_device_id = unsafe { core::mem::zeroed() };	40	let mut of: bindings::of_device_id = unsafe { core::mem::zeroed() };

rust/kernel/prelude.rs+4−1

 //! ```
 #[doc(no_inline)]
-pub use core::pin::Pin;
+pub use core::{
+    mem::{align_of, align_of_val, size_of, size_of_val},
+    pin::Pin,
+};
 pub use ::ffi::{
     c_char, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong, c_ulonglong,

rust/kernel/ptr.rs+228−0

@@ -0,0 +1,228 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	//! Types and functions to work with pointers and addresses.
	4
	5	use core::fmt::Debug;
	6	use core::mem::align_of;
	7	use core::num::NonZero;
	8
	9	use crate::build_assert;
	10
	11	/// Type representing an alignment, which is always a power of two.
	12	///
	13	/// It is used to validate that a given value is a valid alignment, and to perform masking and
	14	/// alignment operations.
	15	///
	16	/// This is a temporary substitute for the [`Alignment`] nightly type from the standard library,
	17	/// and to be eventually replaced by it.
	18	///
	19	/// [`Alignment`]: https://github.com/rust-lang/rust/issues/102070
	20	///
	21	/// # Invariants
	22	///
	23	/// An alignment is always a power of two.
	24	#[repr(transparent)]
	25	#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
	26	pub struct Alignment(NonZero<usize>);
	27
	28	impl Alignment {
	29	/// Validates that `ALIGN` is a power of two at build-time, and returns an [`Alignment`] of the
	30	/// same value.
	31	///
	32	/// A build error is triggered if `ALIGN` is not a power of two.
	33	///
	34	/// # Examples
	35	///
	36	/// ```
	37	/// use kernel::ptr::Alignment;
	38	///
	39	/// let v = Alignment::new::<16>();
	40	/// assert_eq!(v.as_usize(), 16);
	41	/// ```
	42	#[inline(always)]
	43	pub const fn new<const ALIGN: usize>() -> Self {
	44	build_assert!(
	45	ALIGN.is_power_of_two(),
	46	"Provided alignment is not a power of two."
	47	);
	48
	49	// INVARIANT: `align` is a power of two.
	50	// SAFETY: `align` is a power of two, and thus non-zero.
	51	Self(unsafe { NonZero::new_unchecked(ALIGN) })
	52	}
	53
	54	/// Validates that `align` is a power of two at runtime, and returns an
	55	/// [`Alignment`] of the same value.
	56	///
	57	/// Returns [`None`] if `align` is not a power of two.
	58	///
	59	/// # Examples
	60	///
	61	/// ```
	62	/// use kernel::ptr::Alignment;
	63	///
	64	/// assert_eq!(Alignment::new_checked(16), Some(Alignment::new::<16>()));
	65	/// assert_eq!(Alignment::new_checked(15), None);
	66	/// assert_eq!(Alignment::new_checked(1), Some(Alignment::new::<1>()));
	67	/// assert_eq!(Alignment::new_checked(0), None);
	68	/// ```
	69	#[inline(always)]
	70	pub const fn new_checked(align: usize) -> Option<Self> {
	71	if align.is_power_of_two() {
	72	// INVARIANT: `align` is a power of two.
	73	// SAFETY: `align` is a power of two, and thus non-zero.
	74	Some(Self(unsafe { NonZero::new_unchecked(align) }))
	75	} else {
	76	None
	77	}
	78	}
	79
	80	/// Returns the alignment of `T`.
	81	///
	82	/// This is equivalent to [`align_of`], but with the return value provided as an [`Alignment`].
	83	#[inline(always)]
	84	pub const fn of<T>() -> Self {
	85	#![allow(clippy::incompatible_msrv)]
	86	// This cannot panic since alignments are always powers of two.
	87	//
	88	// We unfortunately cannot use `new` as it would require the `generic_const_exprs` feature.
	89	const { Alignment::new_checked(align_of::<T>()).unwrap() }
	90	}
	91
	92	/// Returns this alignment as a [`usize`].
	93	///
	94	/// It is guaranteed to be a power of two.
	95	///
	96	/// # Examples
	97	///
	98	/// ```
	99	/// use kernel::ptr::Alignment;
	100	///
	101	/// assert_eq!(Alignment::new::<16>().as_usize(), 16);
	102	/// ```
	103	#[inline(always)]
	104	pub const fn as_usize(self) -> usize {
	105	self.as_nonzero().get()
	106	}
	107
	108	/// Returns this alignment as a [`NonZero`].
	109	///
	110	/// It is guaranteed to be a power of two.
	111	///
	112	/// # Examples
	113	///
	114	/// ```
	115	/// use kernel::ptr::Alignment;
	116	///
	117	/// assert_eq!(Alignment::new::<16>().as_nonzero().get(), 16);
	118	/// ```
	119	#[inline(always)]
	120	pub const fn as_nonzero(self) -> NonZero<usize> {
	121	// Allow the compiler to know that the value is indeed a power of two. This can help
	122	// optimize some operations down the line, like e.g. replacing divisions by bit shifts.
	123	if !self.0.is_power_of_two() {
	124	// SAFETY: Per the invariants, `self.0` is always a power of two so this block will
	125	// never be reached.
	126	unsafe { core::hint::unreachable_unchecked() }
	127	}
	128	self.0
	129	}
	130
	131	/// Returns the base-2 logarithm of the alignment.
	132	///
	133	/// # Examples
	134	///
	135	/// ```
	136	/// use kernel::ptr::Alignment;
	137	///
	138	/// assert_eq!(Alignment::of::<u8>().log2(), 0);
	139	/// assert_eq!(Alignment::new::<16>().log2(), 4);
	140	/// ```
	141	#[inline(always)]
	142	pub const fn log2(self) -> u32 {
	143	self.0.ilog2()
	144	}
	145
	146	/// Returns the mask for this alignment.
	147	///
	148	/// This is equivalent to `!(self.as_usize() - 1)`.
	149	///
	150	/// # Examples
	151	///
	152	/// ```
	153	/// use kernel::ptr::Alignment;
	154	///
	155	/// assert_eq!(Alignment::new::<0x10>().mask(), !0xf);
	156	/// ```
	157	#[inline(always)]
	158	pub const fn mask(self) -> usize {
	159	// No underflow can occur as the alignment is guaranteed to be a power of two, and thus is
	160	// non-zero.
	161	!(self.as_usize() - 1)
	162	}
	163	}
	164
	165	/// Trait for items that can be aligned against an [`Alignment`].
	166	pub trait Alignable: Sized {
	167	/// Aligns `self` down to `alignment`.
	168	///
	169	/// # Examples
	170	///
	171	/// ```
	172	/// use kernel::ptr::{Alignable, Alignment};
	173	///
	174	/// assert_eq!(0x2f_usize.align_down(Alignment::new::<0x10>()), 0x20);
	175	/// assert_eq!(0x30usize.align_down(Alignment::new::<0x10>()), 0x30);
	176	/// assert_eq!(0xf0u8.align_down(Alignment::new::<0x1000>()), 0x0);
	177	/// ```
	178	fn align_down(self, alignment: Alignment) -> Self;
	179
	180	/// Aligns `self` up to `alignment`, returning `None` if aligning would result in an overflow.
	181	///
	182	/// # Examples
	183	///
	184	/// ```
	185	/// use kernel::ptr::{Alignable, Alignment};
	186	///
	187	/// assert_eq!(0x4fusize.align_up(Alignment::new::<0x10>()), Some(0x50));
	188	/// assert_eq!(0x40usize.align_up(Alignment::new::<0x10>()), Some(0x40));
	189	/// assert_eq!(0x0usize.align_up(Alignment::new::<0x10>()), Some(0x0));
	190	/// assert_eq!(u8::MAX.align_up(Alignment::new::<0x10>()), None);
	191	/// assert_eq!(0x10u8.align_up(Alignment::new::<0x100>()), None);
	192	/// assert_eq!(0x0u8.align_up(Alignment::new::<0x100>()), Some(0x0));
	193	/// ```
	194	fn align_up(self, alignment: Alignment) -> Option<Self>;
	195	}
	196
	197	/// Implement [`Alignable`] for unsigned integer types.
	198	macro_rules! impl_alignable_uint {
	199	($($t:ty),*) => {
	200	$(
	201	impl Alignable for $t {
	202	#[inline(always)]
	203	fn align_down(self, alignment: Alignment) -> Self {
	204	// The operands of `&` need to be of the same type so convert the alignment to
	205	// `Self`. This means we need to compute the mask ourselves.
	206	::core::num::NonZero::<Self>::try_from(alignment.as_nonzero())
	207	.map(\|align\| self & !(align.get() - 1))
	208	// An alignment larger than `Self` always aligns down to `0`.
	209	.unwrap_or(0)
	210	}
	211
	212	#[inline(always)]
	213	fn align_up(self, alignment: Alignment) -> Option<Self> {
	214	let aligned_down = self.align_down(alignment);
	215	if self == aligned_down {
	216	Some(aligned_down)
	217	} else {
	218	Self::try_from(alignment.as_usize())
	219	.ok()
	220	.and_then(\|align\| aligned_down.checked_add(align))
	221	}
	222	}
	223	}
	224	)*
	225	};
	226	}
	227
	228	impl_alignable_uint!(u8, u16, u32, u64, usize);

rust/kernel/seq_file.rs+3−3

@@ -4,7 +4,7 @@ · 3 unmodified lines
4	//!	4	//!
5	//! C header: [`include/linux/seq_file.h`](srctree/include/linux/seq_file.h)	5	//! C header: [`include/linux/seq_file.h`](srctree/include/linux/seq_file.h)
6		6
7	use crate::{bindings, c_str, types::NotThreadSafe, types::Opaque};	7	use crate::{bindings, c_str, fmt, types::NotThreadSafe, types::Opaque};
8		8
9	/// A utility for generating the contents of a seq file.	9	/// A utility for generating the contents of a seq file.
10	#[repr(transparent)]	10	#[repr(transparent)]
@@ -31,7 +31,7 @@ impl SeqFile { · 20 unmodified lines
31		31
32	/// Used by the [`seq_print`] macro.	32	/// Used by the [`seq_print`] macro.
33	#[inline]	33	#[inline]
34	pub fn call_printf(&self, args: core::fmt::Arguments<'_>) {	34	pub fn call_printf(&self, args: fmt::Arguments<'_>) {
35	// SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`.	35	// SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`.
36	unsafe {	36	unsafe {
37	bindings::seq_printf(	37	bindings::seq_printf(
@@ -47,7 +47,7 @@ impl SeqFile { · 9 unmodified lines
47	#[macro_export]	47	#[macro_export]
48	macro_rules! seq_print {	48	macro_rules! seq_print {
49	($m:expr, $($arg:tt)+) => (	49	($m:expr, $($arg:tt)+) => (
50	$m.call_printf(format_args!($($arg)+))	50	$m.call_printf($crate::prelude::fmt!($($arg)+))
51	);	51	);
52	}	52	}
53	pub use seq_print;	53	pub use seq_print;

rust/kernel/sync/arc.rs+4−4

 use crate::{
     alloc::{AllocError, Flags, KBox},
     ffi::c_void,
+    fmt,
     init::InPlaceInit,
     sync::Refcount,
     try_init,
 use core::{
     alloc::Layout,
     borrow::{Borrow, BorrowMut},
-    fmt,
     marker::PhantomData,
     mem::{ManuallyDrop, MaybeUninit},
     ops::{Deref, DerefMut},
     }
 }
-// SAFETY: The pointer returned by `into_foreign` comes from a well aligned
+// SAFETY: The pointer returned by `into_foreign` was originally allocated as an
-// pointer to `ArcInner<T>`.
+// `KBox<ArcInner<T>>`, so that type is what determines the alignment.
 unsafe impl<T: 'static> ForeignOwnable for Arc<T> {
-    const FOREIGN_ALIGN: usize = core::mem::align_of::<ArcInner<T>>();
+    const FOREIGN_ALIGN: usize = <KBox<ArcInner<T>> as ForeignOwnable>::FOREIGN_ALIGN;
     type Borrowed<'a> = ArcBorrow<'a, T>;
     type BorrowedMut<'a> = Self::Borrowed<'a>;

rust/kernel/sync/aref.rs+16−1

@@ -1,6 +1,21 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2		2
3	//! Internal reference counting support.	3	//! Internal reference counting support.
		4	//!
		5	//! Many C types already have their own reference counting mechanism (e.g. by storing a
		6	//! `refcount_t`). This module provides support for directly using their internal reference count
		7	//! from Rust; instead of making users have to use an additional Rust-reference count in the form of
		8	//! [`Arc`].
		9	//!
		10	//! The smart pointer [`ARef<T>`] acts similarly to [`Arc<T>`] in that it holds a refcount on the
		11	//! underlying object, but this refcount is internal to the object. It essentially is a Rust
		12	//! implementation of the `get_` and `put_` pattern used in C for reference counting.
		13	//!
		14	//! To make use of [`ARef<MyType>`], `MyType` needs to implement [`AlwaysRefCounted`]. It is a trait
		15	//! for accessing the internal reference count of an object of the `MyType` type.
		16	//!
		17	//! [`Arc`]: crate::sync::Arc
		18	//! [`Arc<T>`]: crate::sync::Arc
4		19
5	use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};	20	use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
6		21
@@ -97,7 +112,7 @@ impl<T: AlwaysRefCounted> ARef<T> { · 90 unmodified lines
97	///	112	///
98	/// ```	113	/// ```
99	/// use core::ptr::NonNull;	114	/// use core::ptr::NonNull;
100	/// use kernel::types::{ARef, AlwaysRefCounted};	115	/// use kernel::sync::aref::{ARef, AlwaysRefCounted};
101	///	116	///
102	/// struct Empty {}	117	/// struct Empty {}
103	///	118	///

rust/kernel/task.rs+4−3

     ffi::{c_int, c_long, c_uint},
     mm::MmWithUser,
     pid_namespace::PidNamespace,
-    types::{ARef, NotThreadSafe, Opaque},
+    sync::aref::ARef,
+    types::{NotThreadSafe, Opaque},
 };
 use core::{
     cmp::{Eq, PartialEq},
 /// incremented when creating `State` and decremented when it is dropped:
 ///
 /// ```
-/// use kernel::{task::Task, types::ARef};
+/// use kernel::{task::Task, sync::aref::ARef};
 ///
 /// struct State {
 ///     creator: ARef<Task>,
 }
 // SAFETY: The type invariants guarantee that `Task` is always refcounted.
-unsafe impl crate::types::AlwaysRefCounted for Task {
+unsafe impl crate::sync::aref::AlwaysRefCounted for Task {
     #[inline]
     fn inc_ref(&self) {
         // SAFETY: The existence of a shared reference means that the refcount is nonzero.

rust/kernel/time.rs+162−1

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	//! C header: [`include/linux/ktime.h`](srctree/include/linux/ktime.h).	25	//! C header: [`include/linux/ktime.h`](srctree/include/linux/ktime.h).
26		26
27	use core::marker::PhantomData;	27	use core::marker::PhantomData;
		28	use core::ops;
28		29
29	pub mod delay;	30	pub mod delay;
30	pub mod hrtimer;	31	pub mod hrtimer;
@@ -200,9 +201,31 @@ impl<C: ClockSource> Instant<C> { · 169 unmodified lines
200	pub(crate) fn as_nanos(&self) -> i64 {	201	pub(crate) fn as_nanos(&self) -> i64 {
201	self.inner	202	self.inner
202	}	203	}
		204
		205	/// Create an [`Instant`] from a `ktime_t` without checking if it is non-negative.
		206	///
		207	/// # Panics
		208	///
		209	/// On debug builds, this function will panic if `ktime` is not in the range from 0 to
		210	/// `KTIME_MAX`.
		211	///
		212	/// # Safety
		213	///
		214	/// The caller promises that `ktime` is in the range from 0 to `KTIME_MAX`.
		215	#[inline]
		216	pub(crate) unsafe fn from_ktime(ktime: bindings::ktime_t) -> Self {
		217	debug_assert!(ktime >= 0);
		218
		219	// INVARIANT: Our safety contract ensures that `ktime` is in the range from 0 to
		220	// `KTIME_MAX`.
		221	Self {
		222	inner: ktime,
		223	_c: PhantomData,
		224	}
		225	}
203	}	226	}
204		227
205	impl<C: ClockSource> core::ops::Sub for Instant<C> {	228	impl<C: ClockSource> ops::Sub for Instant<C> {
206	type Output = Delta;	229	type Output = Delta;
207		230
208	// By the type invariant, it never overflows.	231	// By the type invariant, it never overflows.
@@ -214,6 +237,46 @@ impl<C: ClockSource> core::ops::Sub for Instant<C> { · 5 unmodified lines
214	}	237	}
215	}	238	}
216		239
		240	impl<T: ClockSource> ops::Add<Delta> for Instant<T> {
		241	type Output = Self;
		242
		243	#[inline]
		244	fn add(self, rhs: Delta) -> Self::Output {
		245	// INVARIANT: With arithmetic over/underflow checks enabled, this will panic if we overflow
		246	// (e.g. go above `KTIME_MAX`)
		247	let res = self.inner + rhs.nanos;
		248
		249	// INVARIANT: With overflow checks enabled, we verify here that the value is >= 0
		250	#[cfg(CONFIG_RUST_OVERFLOW_CHECKS)]
		251	assert!(res >= 0);
		252
		253	Self {
		254	inner: res,
		255	_c: PhantomData,
		256	}
		257	}
		258	}
		259
		260	impl<T: ClockSource> ops::Sub<Delta> for Instant<T> {
		261	type Output = Self;
		262
		263	#[inline]
		264	fn sub(self, rhs: Delta) -> Self::Output {
		265	// INVARIANT: With arithmetic over/underflow checks enabled, this will panic if we overflow
		266	// (e.g. go above `KTIME_MAX`)
		267	let res = self.inner - rhs.nanos;
		268
		269	// INVARIANT: With overflow checks enabled, we verify here that the value is >= 0
		270	#[cfg(CONFIG_RUST_OVERFLOW_CHECKS)]
		271	assert!(res >= 0);
		272
		273	Self {
		274	inner: res,
		275	_c: PhantomData,
		276	}
		277	}
		278	}
		279
217	/// A span of time.	280	/// A span of time.
218	///	281	///
219	/// This struct represents a span of time, with its value stored as nanoseconds.	282	/// This struct represents a span of time, with its value stored as nanoseconds.
@@ -224,6 +287,78 @@ pub struct Delta { · 4 unmodified lines
224	nanos: i64,	287	nanos: i64,
225	}	288	}
226		289
		290	impl ops::Add for Delta {
		291	type Output = Self;
		292
		293	#[inline]
		294	fn add(self, rhs: Self) -> Self {
		295	Self {
		296	nanos: self.nanos + rhs.nanos,
		297	}
		298	}
		299	}
		300
		301	impl ops::AddAssign for Delta {
		302	#[inline]
		303	fn add_assign(&mut self, rhs: Self) {
		304	self.nanos += rhs.nanos;
		305	}
		306	}
		307
		308	impl ops::Sub for Delta {
		309	type Output = Self;
		310
		311	#[inline]
		312	fn sub(self, rhs: Self) -> Self::Output {
		313	Self {
		314	nanos: self.nanos - rhs.nanos,
		315	}
		316	}
		317	}
		318
		319	impl ops::SubAssign for Delta {
		320	#[inline]
		321	fn sub_assign(&mut self, rhs: Self) {
		322	self.nanos -= rhs.nanos;
		323	}
		324	}
		325
		326	impl ops::Mul<i64> for Delta {
		327	type Output = Self;
		328
		329	#[inline]
		330	fn mul(self, rhs: i64) -> Self::Output {
		331	Self {
		332	nanos: self.nanos * rhs,
		333	}
		334	}
		335	}
		336
		337	impl ops::MulAssign<i64> for Delta {
		338	#[inline]
		339	fn mul_assign(&mut self, rhs: i64) {
		340	self.nanos *= rhs;
		341	}
		342	}
		343
		344	impl ops::Div for Delta {
		345	type Output = i64;
		346
		347	#[inline]
		348	fn div(self, rhs: Self) -> Self::Output {
		349	#[cfg(CONFIG_64BIT)]
		350	{
		351	self.nanos / rhs.nanos
		352	}
		353
		354	#[cfg(not(CONFIG_64BIT))]
		355	{
		356	// SAFETY: This function is always safe to call regardless of the input values
		357	unsafe { bindings::div64_s64(self.nanos, rhs.nanos) }
		358	}
		359	}
		360	}
		361
227	impl Delta {	362	impl Delta {
228	/// A span of time equal to zero.	363	/// A span of time equal to zero.
229	pub const ZERO: Self = Self { nanos: 0 };	364	pub const ZERO: Self = Self { nanos: 0 };
@@ -312,4 +447,30 @@ impl Delta { · 82 unmodified lines
312	bindings::ktime_to_ms(self.as_nanos())	447	bindings::ktime_to_ms(self.as_nanos())
313	}	448	}
314	}	449	}
		450
		451	/// Return `self % dividend` where `dividend` is in nanoseconds.
		452	///
		453	/// The kernel doesn't have any emulation for `s64 % s64` on 32 bit platforms, so this is
		454	/// limited to 32 bit dividends.
		455	#[inline]
		456	pub fn rem_nanos(self, dividend: i32) -> Self {
		457	#[cfg(CONFIG_64BIT)]
		458	{
		459	Self {
		460	nanos: self.as_nanos() % i64::from(dividend),
		461	}
		462	}
		463
		464	#[cfg(not(CONFIG_64BIT))]
		465	{
		466	let mut rem = 0;
		467
		468	// SAFETY: `rem` is in the stack, so we can always provide a valid pointer to it.
		469	unsafe { bindings::div_s64_rem(self.as_nanos(), dividend, &mut rem) };
		470
		471	Self {
		472	nanos: i64::from(rem),
		473	}
		474	}
		475	}
315	}	476	}

rust/kernel/time/hrtimer.rs+149−3

@@ -69,9 +69,14 @@ · 68 unmodified lines
69		69
70	use super::{ClockSource, Delta, Instant};	70	use super::{ClockSource, Delta, Instant};
71	use crate::{prelude::*, types::Opaque};	71	use crate::{prelude::*, types::Opaque};
72	use core::marker::PhantomData;	72	use core::{marker::PhantomData, ptr::NonNull};
73	use pin_init::PinInit;	73	use pin_init::PinInit;
74		74
		75	/// A type-alias to refer to the [`Instant<C>`] for a given `T` from [`HrTimer<T>`].
		76	///
		77	/// Where `C` is the [`ClockSource`] of the [`HrTimer`].
		78	pub type HrTimerInstant<T> = Instant<<<T as HasHrTimer<T>>::TimerMode as HrTimerMode>::Clock>;
		79
75	/// A timer backed by a C `struct hrtimer`.	80	/// A timer backed by a C `struct hrtimer`.
76	///	81	///
77	/// # Invariants	82	/// # Invariants
@@ -163,6 +168,84 @@ impl<T> HrTimer<T> { · 85 unmodified lines
163	// handled on the C side.	168	// handled on the C side.
164	unsafe { bindings::hrtimer_cancel(c_timer_ptr) != 0 }	169	unsafe { bindings::hrtimer_cancel(c_timer_ptr) != 0 }
165	}	170	}
		171
		172	/// Forward the timer expiry for a given timer pointer.
		173	///
		174	/// # Safety
		175	///
		176	/// - `self_ptr` must point to a valid `Self`.
		177	/// - The caller must either have exclusive access to the data pointed at by `self_ptr`, or be
		178	/// within the context of the timer callback.
		179	#[inline]
		180	unsafe fn raw_forward(self_ptr: *mut Self, now: HrTimerInstant<T>, interval: Delta) -> u64
		181	where
		182	T: HasHrTimer<T>,
		183	{
		184	// SAFETY:
		185	// * The C API requirements for this function are fulfilled by our safety contract.
		186	// * `self_ptr` is guaranteed to point to a valid `Self` via our safety contract
		187	unsafe {
		188	bindings::hrtimer_forward(Self::raw_get(self_ptr), now.as_nanos(), interval.as_nanos())
		189	}
		190	}
		191
		192	/// Conditionally forward the timer.
		193	///
		194	/// If the timer expires after `now`, this function does nothing and returns 0. If the timer
		195	/// expired at or before `now`, this function forwards the timer by `interval` until the timer
		196	/// expires after `now` and then returns the number of times the timer was forwarded by
		197	/// `interval`.
		198	///
		199	/// This function is mainly useful for timer types which can provide exclusive access to the
		200	/// timer when the timer is not running. For forwarding the timer from within the timer callback
		201	/// context, see [`HrTimerCallbackContext::forward()`].
		202	///
		203	/// Returns the number of overruns that occurred as a result of the timer expiry change.
		204	pub fn forward(self: Pin<&mut Self>, now: HrTimerInstant<T>, interval: Delta) -> u64
		205	where
		206	T: HasHrTimer<T>,
		207	{
		208	// SAFETY: `raw_forward` does not move `Self`
		209	let this = unsafe { self.get_unchecked_mut() };
		210
		211	// SAFETY: By existence of `Pin<&mut Self>`, the pointer passed to `raw_forward` points to a
		212	// valid `Self` that we have exclusive access to.
		213	unsafe { Self::raw_forward(this, now, interval) }
		214	}
		215
		216	/// Conditionally forward the timer.
		217	///
		218	/// This is a variant of [`forward()`](Self::forward) that uses an interval after the current
		219	/// time of the base clock for the [`HrTimer`].
		220	pub fn forward_now(self: Pin<&mut Self>, interval: Delta) -> u64
		221	where
		222	T: HasHrTimer<T>,
		223	{
		224	self.forward(HrTimerInstant::<T>::now(), interval)
		225	}
		226
		227	/// Return the time expiry for this [`HrTimer`].
		228	///
		229	/// This value should only be used as a snapshot, as the actual expiry time could change after
		230	/// this function is called.
		231	pub fn expires(&self) -> HrTimerInstant<T>
		232	where
		233	T: HasHrTimer<T>,
		234	{
		235	// SAFETY: `self` is an immutable reference and thus always points to a valid `HrTimer`.
		236	let c_timer_ptr = unsafe { HrTimer::raw_get(self) };
		237
		238	// SAFETY:
		239	// - Timers cannot have negative ktime_t values as their expiration time.
		240	// - There's no actual locking here, a racy read is fine and expected
		241	unsafe {
		242	Instant::from_ktime(
		243	// This `read_volatile` is intended to correspond to a READ_ONCE call.
		244	// FIXME(read_once): Replace with `read_once` when available on the Rust side.
		245	core::ptr::read_volatile(&raw const ((*c_timer_ptr).node.expires)),
		246	)
		247	}
		248	}
166	}	249	}
167		250
168	/// Implemented by pointer types that point to structs that contain a [`HrTimer`].	251	/// Implemented by pointer types that point to structs that contain a [`HrTimer`].
@@ -300,9 +383,13 @@ pub trait HrTimerCallback { · 131 unmodified lines
300	type Pointer<'a>: RawHrTimerCallback;	383	type Pointer<'a>: RawHrTimerCallback;
301		384
302	/// Called by the timer logic when the timer fires.	385	/// Called by the timer logic when the timer fires.
303	fn run(this: <Self::Pointer<'_> as RawHrTimerCallback>::CallbackTarget<'_>) -> HrTimerRestart	386	fn run(
		387	this: <Self::Pointer<'_> as RawHrTimerCallback>::CallbackTarget<'_>,
		388	ctx: HrTimerCallbackContext<'_, Self>,
		389	) -> HrTimerRestart
304	where	390	where
305	Self: Sized;	391	Self: Sized,
		392	Self: HasHrTimer<Self>;
306	}	393	}
307		394
308	/// A handle representing a potentially running timer.	395	/// A handle representing a potentially running timer.
@@ -324,6 +411,8 @@ pub unsafe trait HrTimerHandle { · 15 unmodified lines
324	/// Note that the timer might be started by a concurrent start operation. If	411	/// Note that the timer might be started by a concurrent start operation. If
325	/// so, the timer might not be in the stopped state when this function	412	/// so, the timer might not be in the stopped state when this function
326	/// returns.	413	/// returns.
		414	///
		415	/// Returns `true` if the timer was running.
327	fn cancel(&mut self) -> bool;	416	fn cancel(&mut self) -> bool;
328	}	417	}
329		418
@@ -585,6 +674,63 @@ impl<C: ClockSource> HrTimerMode for RelativePinnedHardMode<C> { · 255 unmodified lines
585	type Expires = Delta;	674	type Expires = Delta;
586	}	675	}
587		676
		677	/// Privileged smart-pointer for a [`HrTimer`] callback context.
		678	///
		679	/// Many [`HrTimer`] methods can only be called in two situations:
		680	///
		681	/// * When the caller has exclusive access to the `HrTimer` and the `HrTimer` is guaranteed not to
		682	/// be running.
		683	/// * From within the context of an `HrTimer`'s callback method.
		684	///
		685	/// This type provides access to said methods from within a timer callback context.
		686	///
		687	/// # Invariants
		688	///
		689	/// * The existence of this type means the caller is currently within the callback for an
		690	/// [`HrTimer`].
		691	/// * `self.0` always points to a live instance of [`HrTimer<T>`].
		692	pub struct HrTimerCallbackContext<'a, T: HasHrTimer<T>>(NonNull<HrTimer<T>>, PhantomData<&'a ()>);
		693
		694	impl<'a, T: HasHrTimer<T>> HrTimerCallbackContext<'a, T> {
		695	/// Create a new [`HrTimerCallbackContext`].
		696	///
		697	/// # Safety
		698	///
		699	/// This function relies on the caller being within the context of a timer callback, so it must
		700	/// not be used anywhere except for within implementations of [`RawHrTimerCallback::run`]. The
		701	/// caller promises that `timer` points to a valid initialized instance of
		702	/// [`bindings::hrtimer`].
		703	///
		704	/// The returned `Self` must not outlive the function context of [`RawHrTimerCallback::run`]
		705	/// where this function is called.
		706	pub(crate) unsafe fn from_raw(timer: *mut HrTimer<T>) -> Self {
		707	// SAFETY: The caller guarantees `timer` is a valid pointer to an initialized
		708	// `bindings::hrtimer`
		709	// INVARIANT: Our safety contract ensures that we're within the context of a timer callback
		710	// and that `timer` points to a live instance of `HrTimer<T>`.
		711	Self(unsafe { NonNull::new_unchecked(timer) }, PhantomData)
		712	}
		713
		714	/// Conditionally forward the timer.
		715	///
		716	/// This function is identical to [`HrTimer::forward()`] except that it may only be used from
		717	/// within the context of a [`HrTimer`] callback.
		718	pub fn forward(&mut self, now: HrTimerInstant<T>, interval: Delta) -> u64 {
		719	// SAFETY:
		720	// - We are guaranteed to be within the context of a timer callback by our type invariants
		721	// - By our type invariants, `self.0` always points to a valid `HrTimer<T>`
		722	unsafe { HrTimer::<T>::raw_forward(self.0.as_ptr(), now, interval) }
		723	}
		724
		725	/// Conditionally forward the timer.
		726	///
		727	/// This is a variant of [`HrTimerCallbackContext::forward()`] that uses an interval after the
		728	/// current time of the base clock for the [`HrTimer`].
		729	pub fn forward_now(&mut self, duration: Delta) -> u64 {
		730	self.forward(HrTimerInstant::<T>::now(), duration)
		731	}
		732	}
		733
588	/// Use to implement the [`HasHrTimer<T>`] trait.	734	/// Use to implement the [`HasHrTimer<T>`] trait.
589	///	735	///
590	/// See [`module`] documentation for an example.	736	/// See [`module`] documentation for an example.

rust/kernel/time/hrtimer/arc.rs+8−1

 use super::HasHrTimer;
 use super::HrTimer;
 use super::HrTimerCallback;
+use super::HrTimerCallbackContext;
 use super::HrTimerHandle;
 use super::HrTimerMode;
 use super::HrTimerPointer;
         //    allocation from other `Arc` clones.
         let receiver = unsafe { ArcBorrow::from_raw(data_ptr) };
-        T::run(receiver).into_c()
+        // SAFETY:
+        // - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so
+        //   it is a valid pointer to a `HrTimer<T>` embedded in a `T`.
+        // - We are within `RawHrTimerCallback::run`
+        let context = unsafe { HrTimerCallbackContext::from_raw(timer_ptr) };
+        T::run(receiver, context).into_c()
     }
 }

rust/kernel/time/hrtimer/pin.rs+8−1

 use super::HasHrTimer;
 use super::HrTimer;
 use super::HrTimerCallback;
+use super::HrTimerCallbackContext;
 use super::HrTimerHandle;
 use super::HrTimerMode;
 use super::RawHrTimerCallback;
         // here.
         let receiver_pin = unsafe { Pin::new_unchecked(receiver_ref) };
-        T::run(receiver_pin).into_c()
+        // SAFETY:
+        // - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so
+        //   it is a valid pointer to a `HrTimer<T>` embedded in a `T`.
+        // - We are within `RawHrTimerCallback::run`
+        let context = unsafe { HrTimerCallbackContext::from_raw(timer_ptr) };
+        T::run(receiver_pin, context).into_c()
     }
 }

rust/kernel/time/hrtimer/pin_mut.rs+9−3

 // SPDX-License-Identifier: GPL-2.0
 use super::{
-    HasHrTimer, HrTimer, HrTimerCallback, HrTimerHandle, HrTimerMode, RawHrTimerCallback,
+    HasHrTimer, HrTimer, HrTimerCallback, HrTimerCallbackContext, HrTimerHandle, HrTimerMode,
-    UnsafeHrTimerPointer,
+    RawHrTimerCallback, UnsafeHrTimerPointer,
 };
 use core::{marker::PhantomData, pin::Pin, ptr::NonNull};
         // here.
         let receiver_pin = unsafe { Pin::new_unchecked(receiver_ref) };
-        T::run(receiver_pin).into_c()
+        // SAFETY:
+        // - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so
+        //   it is a valid pointer to a `HrTimer<T>` embedded in a `T`.
+        // - We are within `RawHrTimerCallback::run`
+        let context = unsafe { HrTimerCallbackContext::from_raw(timer_ptr) };
+        T::run(receiver_pin, context).into_c()
     }
 }

rust/kernel/time/hrtimer/tbox.rs+8−1

 use super::HasHrTimer;
 use super::HrTimer;
 use super::HrTimerCallback;
+use super::HrTimerCallbackContext;
 use super::HrTimerHandle;
 use super::HrTimerMode;
 use super::HrTimerPointer;
         //   `data_ptr` exist.
         let data_mut_ref = unsafe { Pin::new_unchecked(&mut *data_ptr) };
-        T::run(data_mut_ref).into_c()
+        // SAFETY:
+        // - By C API contract `timer_ptr` is the pointer that we passed when queuing the timer, so
+        //   it is a valid pointer to a `HrTimer<T>` embedded in a `T`.
+        // - We are within `RawHrTimerCallback::run`
+        let context = unsafe { HrTimerCallbackContext::from_raw(timer_ptr) };
+        T::run(data_mut_ref, context).into_c()
     }
 }

rust/macros/quote.rs+49−55

 use proc_macro::{TokenStream, TokenTree};
-#[allow(dead_code)]
 pub(crate) trait ToTokens {
     fn to_tokens(&self, tokens: &mut TokenStream);
 }
 /// `quote` crate but provides only just enough functionality needed by the current `macros` crate.
 macro_rules! quote_spanned {
     ($span:expr => $($tt:tt)*) => {{
-        let mut tokens: ::std::vec::Vec<::proc_macro::TokenTree>;
+        let mut tokens = ::proc_macro::TokenStream::new();
-        #[allow(clippy::vec_init_then_push)]
         {
-            tokens = ::std::vec::Vec::new();
             let span = $span;
             quote_spanned!(@proc tokens span $($tt)*);
         }
-        ::proc_macro::TokenStream::from_iter(tokens)
+        tokens
     }};
     (@proc $v:ident $span:ident) => {};
     (@proc $v:ident $span:ident #$id:ident $($tt:tt)*) => {
-        let mut ts = ::proc_macro::TokenStream::new();
+        $crate::quote::ToTokens::to_tokens(&$id, &mut $v);
-        $crate::quote::ToTokens::to_tokens(&$id, &mut ts);
-        $v.extend(ts);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident #(#$id:ident)* $($tt:tt)*) => {
         for token in $id {
-            let mut ts = ::proc_macro::TokenStream::new();
+            $crate::quote::ToTokens::to_tokens(&token, &mut $v);
-            $crate::quote::ToTokens::to_tokens(&token, &mut ts);
-            $v.extend(ts);
         }
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident ( $($inner:tt)* ) $($tt:tt)*) => {
         #[allow(unused_mut)]
-        let mut tokens = ::std::vec::Vec::<::proc_macro::TokenTree>::new();
+        let mut tokens = ::proc_macro::TokenStream::new();
         quote_spanned!(@proc tokens $span $($inner)*);
-        $v.push(::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+        $v.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new(
             ::proc_macro::Delimiter::Parenthesis,
-            ::proc_macro::TokenStream::from_iter(tokens)
+            tokens,
-        )));
+        ))]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident [ $($inner:tt)* ] $($tt:tt)*) => {
-        let mut tokens = ::std::vec::Vec::new();
+        let mut tokens = ::proc_macro::TokenStream::new();
         quote_spanned!(@proc tokens $span $($inner)*);
-        $v.push(::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+        $v.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new(
             ::proc_macro::Delimiter::Bracket,
-            ::proc_macro::TokenStream::from_iter(tokens)
+            tokens,
-        )));
+        ))]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident { $($inner:tt)* } $($tt:tt)*) => {
-        let mut tokens = ::std::vec::Vec::new();
+        let mut tokens = ::proc_macro::TokenStream::new();
         quote_spanned!(@proc tokens $span $($inner)*);
-        $v.push(::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+        $v.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new(
             ::proc_macro::Delimiter::Brace,
-            ::proc_macro::TokenStream::from_iter(tokens)
+            tokens,
-        )));
+        ))]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident :: $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::Spacing::Joint, ::proc_macro::Spacing::Alone].map(|spacing| {
-                ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Joint)
+            ::proc_macro::TokenTree::Punct(::proc_macro::Punct::new(':', spacing))
-        ));
+        }));
-        $v.push(::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Alone)
-        ));
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident : $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident , $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new(',', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new(',', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident @ $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new('@', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new('@', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident ! $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new('!', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new('!', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident ; $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new(';', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new(';', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident + $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new('+', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new('+', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident = $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new('=', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new('=', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident # $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Punct(
+        $v.extend([::proc_macro::TokenTree::Punct(
-                ::proc_macro::Punct::new('#', ::proc_macro::Spacing::Alone)
+            ::proc_macro::Punct::new('#', ::proc_macro::Spacing::Alone),
-        ));
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident _ $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Ident(::proc_macro::Ident::new("_", $span)));
+        $v.extend([::proc_macro::TokenTree::Ident(
+            ::proc_macro::Ident::new("_", $span),
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
     (@proc $v:ident $span:ident $id:ident $($tt:tt)*) => {
-        $v.push(::proc_macro::TokenTree::Ident(::proc_macro::Ident::new(stringify!($id), $span)));
+        $v.extend([::proc_macro::TokenTree::Ident(
+            ::proc_macro::Ident::new(stringify!($id), $span),
+        )]);
         quote_spanned!(@proc $v $span $($tt)*);
     };
 }

rust/uapi/lib.rs+2−0

@@ -34,4 +34,6 @@ type __kernel_size_t = usize; · 33 unmodified lines
34	type __kernel_ssize_t = isize;	34	type __kernel_ssize_t = isize;
35	type __kernel_ptrdiff_t = isize;	35	type __kernel_ptrdiff_t = isize;
36		36
		37	use pin_init::MaybeZeroable;
		38
37	include!(concat!(env!("OBJTREE"), "/rust/uapi/uapi_generated.rs"));	39	include!(concat!(env!("OBJTREE"), "/rust/uapi/uapi_generated.rs"));

samples/rust/rust_configfs.rs+1−1

@@ -94,7 +94,7 @@ impl configfs::AttributeOperations<0> for Configuration { · 93 unmodified lines
94		94
95	fn show(container: &Configuration, page: &mut [u8; PAGE_SIZE]) -> Result<usize> {	95	fn show(container: &Configuration, page: &mut [u8; PAGE_SIZE]) -> Result<usize> {
96	pr_info!("Show message\n");	96	pr_info!("Show message\n");
97	let data = container.message;	97	let data = container.message.to_bytes();
98	page[0..data.len()].copy_from_slice(data);	98	page[0..data.len()].copy_from_slice(data);
99	Ok(data.len())	99	Ok(data.len())
100	}	100	}

samples/rust/rust_dma.rs+1−1

@@ -10,7 +10,7 @@ use kernel::{ · 9 unmodified lines
10	dma::{CoherentAllocation, Device, DmaMask},	10	dma::{CoherentAllocation, Device, DmaMask},
11	pci,	11	pci,
12	prelude::*,	12	prelude::*,
13	types::ARef,	13	sync::aref::ARef,
14	};	14	};
15		15
16	struct DmaSampleDriver {	16	struct DmaSampleDriver {

scripts/generate_rust_analyzer.py+2−2

@@ -139,8 +139,8 @@ def generate_crates(srctree, objtree, sysroot_src, external_src, cfgs, core_edit · 138 unmodified lines
139	"exclude_dirs": [],	139	"exclude_dirs": [],
140	}	140	}
141		141
142	append_crate_with_generated("bindings", ["core", "ffi"])	142	append_crate_with_generated("bindings", ["core", "ffi", "pin_init"])
143	append_crate_with_generated("uapi", ["core", "ffi"])	143	append_crate_with_generated("uapi", ["core", "ffi", "pin_init"])
144	append_crate_with_generated("kernel", ["core", "macros", "build_error", "pin_init", "ffi", "bindings", "uapi"])	144	append_crate_with_generated("kernel", ["core", "macros", "build_error", "pin_init", "ffi", "bindings", "uapi"])
145		145
146	def is_root_crate(build_file, target):	146	def is_root_crate(build_file, target):

scripts/rustdoc_test_gen.rs+1−1

@@ -202,7 +202,7 @@ pub extern "C" fn {kunit_name}(__kunit_test: *mut ::kernel::bindings::kunit) {{ · 201 unmodified lines
202	// This follows the syntax for declaring test metadata in the proposed KTAP v2 spec, which may	202	// This follows the syntax for declaring test metadata in the proposed KTAP v2 spec, which may
203	// be used for the proposed KUnit test attributes API. Thus hopefully this will make migration	203	// be used for the proposed KUnit test attributes API. Thus hopefully this will make migration
204	// easier later on.	204	// easier later on.
205	::kernel::kunit::info(format_args!(" # {kunit_name}.location: {real_path}:{line}\n"));	205	::kernel::kunit::info(fmt!(" # {kunit_name}.location: {real_path}:{line}\n"));
206		206
207	/// The anchor where the test code body starts.	207	/// The anchor where the test code body starts.
208	#[allow(unused)]	208	#[allow(unused)]