mm: rust: make CONFIG_MMU ifdefs more narrow (5a789772) · Commits · git / linux-net

rust/kernel/mm.rs

+4 −52

Original line number	Diff line number	Diff line
		@@ -10,7 +10,6 @@
		//! control what happens when userspace reads or writes to that region of memory.
		//!
		//! C header: [`include/linux/mm.h`](srctree/include/linux/mm.h)
		#![cfg(CONFIG_MMU)]

		use crate::{
		bindings,
		@@ -21,6 +20,10 @@
		pub mod virt;
		use virt::VmaRef;

		#[cfg(CONFIG_MMU)]
		pub use mmput_async::MmWithUserAsync;
		mod mmput_async;

		/// A wrapper for the kernel's `struct mm_struct`.
		///
		/// This represents the address space of a userspace process, so each process has one `Mm`
		@@ -111,50 +114,6 @@ fn deref(&self) -> &Mm {
		}
		}

		/// A wrapper for the kernel's `struct mm_struct`.
		///
		/// This type is identical to `MmWithUser` except that it uses `mmput_async` when dropping a
		/// refcount. This means that the destructor of `ARef<MmWithUserAsync>` is safe to call in atomic
		/// context.
		///
		/// # Invariants
		///
		/// Values of this type are always refcounted using `mmget`. The value of `mm_users` is non-zero.
		#[repr(transparent)]
		pub struct MmWithUserAsync {
		mm: MmWithUser,
		}

		// SAFETY: It is safe to call `mmput_async` on another thread than where `mmget` was called.
		unsafe impl Send for MmWithUserAsync {}
		// SAFETY: All methods on `MmWithUserAsync` can be called in parallel from several threads.
		unsafe impl Sync for MmWithUserAsync {}

		// SAFETY: By the type invariants, this type is always refcounted.
		unsafe impl AlwaysRefCounted for MmWithUserAsync {
		#[inline]
		fn inc_ref(&self) {
		// SAFETY: The pointer is valid since self is a reference.
		unsafe { bindings::mmget(self.as_raw()) };
		}

		#[inline]
		unsafe fn dec_ref(obj: NonNull<Self>) {
		// SAFETY: The caller is giving up their refcount.
		unsafe { bindings::mmput_async(obj.cast().as_ptr()) };
		}
		}

		// Make all `MmWithUser` methods available on `MmWithUserAsync`.
		impl Deref for MmWithUserAsync {
		type Target = MmWithUser;

		#[inline]
		fn deref(&self) -> &MmWithUser {
		&self.mm
		}
		}

		// These methods are safe to call even if `mm_users` is zero.
		impl Mm {
		/// Returns a raw pointer to the inner `mm_struct`.
		@@ -206,13 +165,6 @@ pub unsafe fn from_raw<'a>(ptr: *const bindings::mm_struct) -> &'a MmWithUser {
		unsafe { &*ptr.cast() }
		}

		/// Use `mmput_async` when dropping this refcount.
		#[inline]
		pub fn into_mmput_async(me: ARef<MmWithUser>) -> ARef<MmWithUserAsync> {
		// SAFETY: The layouts and invariants are compatible.
		unsafe { ARef::from_raw(ARef::into_raw(me).cast()) }
		}

		/// Attempt to access a vma using the vma read lock.
		///
		/// This is an optimistic trylock operation, so it may fail if there is contention. In that

rust/kernel/mm/mmput_async.rs

0 → 100644

+68 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0

		// Copyright (C) 2024 Google LLC.

		//! Version of `MmWithUser` using `mmput_async`.
		//!
		//! This is a separate file from `mm.rs` due to the dependency on `CONFIG_MMU=y`.
		#![cfg(CONFIG_MMU)]

		use crate::{
		bindings,
		mm::MmWithUser,
		types::{ARef, AlwaysRefCounted},
		};
		use core::{ops::Deref, ptr::NonNull};

		/// A wrapper for the kernel's `struct mm_struct`.
		///
		/// This type is identical to `MmWithUser` except that it uses `mmput_async` when dropping a
		/// refcount. This means that the destructor of `ARef<MmWithUserAsync>` is safe to call in atomic
		/// context.
		///
		/// # Invariants
		///
		/// Values of this type are always refcounted using `mmget`. The value of `mm_users` is non-zero.
		#[repr(transparent)]
		pub struct MmWithUserAsync {
		mm: MmWithUser,
		}

		// SAFETY: It is safe to call `mmput_async` on another thread than where `mmget` was called.
		unsafe impl Send for MmWithUserAsync {}
		// SAFETY: All methods on `MmWithUserAsync` can be called in parallel from several threads.
		unsafe impl Sync for MmWithUserAsync {}

		// SAFETY: By the type invariants, this type is always refcounted.
		unsafe impl AlwaysRefCounted for MmWithUserAsync {
		#[inline]
		fn inc_ref(&self) {
		// SAFETY: The pointer is valid since self is a reference.
		unsafe { bindings::mmget(self.as_raw()) };
		}

		#[inline]
		unsafe fn dec_ref(obj: NonNull<Self>) {
		// SAFETY: The caller is giving up their refcount.
		unsafe { bindings::mmput_async(obj.cast().as_ptr()) };
		}
		}

		// Make all `MmWithUser` methods available on `MmWithUserAsync`.
		impl Deref for MmWithUserAsync {
		type Target = MmWithUser;

		#[inline]
		fn deref(&self) -> &MmWithUser {
		&self.mm
		}
		}

		impl MmWithUser {
		/// Use `mmput_async` when dropping this refcount.
		#[inline]
		pub fn into_mmput_async(me: ARef<MmWithUser>) -> ARef<MmWithUserAsync> {
		// SAFETY: The layouts and invariants are compatible.
		unsafe { ARef::from_raw(ARef::into_raw(me).cast()) }
		}
		}