69 lines
2.0 KiB
Rust
69 lines
2.0 KiB
Rust
// 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()) }
|
|
}
|
|
}
|