rust: mm: add abstractions for mm_struct and vm_area_struct
Subsystems (3)
Alice Ryhl
maintainerPATCH v3 1/1 rust: mm: add abstractions for mm_struct and vm_area_struct
This is a follow-up to the page abstractions [1] that were recently merged in 6.11. Rust Binder will need these abstractions to manipulate the vma in its implementation of the mmap fop on the Binder file.
This patch is based on Wedson's implementation on the old rust branch, but has been changed significantly. All mistakes are Alice's.
---
Changes in v3:
- Reorder entries in mm.rs.
- Use ARef for mmput_async helper.
- Clarify that VmArea requires you to hold the mmap read or write lock.
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- mm.rs is redesigned from scratch making use of AsRef
- Add notes about whether destructors may sleep
- Rename Area to VmArea
- Link to v1: https://lore.kernel.org/r/[email protected]
--- rust/helpers.c | 61 +++++++++ rust/kernel/lib.rs | 1 + rust/kernel/mm.rs | 337 +++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/mm/virt.rs | 204 ++++++++++++++++++++++++++++++ rust/kernel/types.rs | 9 ++ 5 files changed, 612 insertions(+)
rust/helpers.c +61 -0
@@ -200,6 +200,67 @@ rust_helper_krealloc(const void *objp, size_t new_size, gfp_t flags) }EXPORT_SYMBOL_GPL (rust_helper_krealloc); +void rust_helper_mmgrab (struct mm_struct *mm) +{ +mmgrab (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmgrab); + +void rust_helper_mmdrop (struct mm_struct *mm) +{ +mmdrop (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmdrop); + +void rust_helper_mmget (struct mm_struct *mm) +{ +mmget (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmget); + +bool rust_helper_mmget_not_zero (struct mm_struct *mm) +{ +return mmget_not_zero (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmget_not_zero); + +void rust_helper_mmap_read_lock (struct mm_struct *mm) +{ +mmap_read_lock (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmap_read_lock); + +bool rust_helper_mmap_read_trylock (struct mm_struct *mm) +{ +return mmap_read_trylock (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmap_read_trylock); + +void rust_helper_mmap_read_unlock (struct mm_struct *mm) +{ +mmap_read_unlock (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmap_read_unlock); + +void rust_helper_mmap_write_lock (struct mm_struct *mm) +{ +mmap_write_lock (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmap_write_lock); + +void rust_helper_mmap_write_unlock (struct mm_struct *mm) +{ +mmap_write_unlock (mm); +} +EXPORT_SYMBOL_GPL (rust_helper_mmap_write_unlock); + +struct vm_area_struct *rust_helper_vma_lookup (struct mm_struct *mm, +unsigned long addr) +{ +return vma_lookup (mm, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_vma_lookup); +/* * `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can * use it in contexts where Rust expects a `usize` like slice (array) indices.
rust/kernel/lib.rs +1 -0
@@ -38,6 +38,7 @@pub mod ioctl;#[cfg( CONFIG_KUNIT )] pub mod kunit; +pub mod mm;#[cfg( CONFIG_NET )] pub mod net;pub mod page;
rust/kernel/mm.rs new file +337 -0
337 lines not on this page · raw message
rust/kernel/mm/virt.rs new file +204 -0
204 lines not on this page · raw message
rust/kernel/types.rs +9 -0
@@ -366,6 +366,15 @@ pub unsafe fn from_raw(ptr: NonNull<T>) -> Self { _p: PhantomData, } } + +/// Pass ownership of the refcount to a raw pointer. +pub fn into_raw (self) ->NonNull <T > { +let ptr = self.ptr; +// Skip the destructor. + core::mem::forget (self); + + ptr + } }impl <T :AlwaysRefCounted >Clone for ARef <T > {
---
base-commit: 8400291e289ee6b2bf9779ff1c83a291501f017b
change-id: 20240723-vma-f80119f9fb35
Best regards,
Signature · 1 line
Alice Ryhl <[email protected]>
Quoted 19 lines · Alice Ryhl
rust/kernel/mm.rs new file +13
-0@@ -0,0 +1,337 @@ +// SPDX-License-Identifier: GPL-2.0 + +// Copyright (C) 2024 Google LLC. + +//! Memory management. +//! +//! C header: [`include/linux/mm.h`](../../../../include/linux/mm.h) + +use crate ::{ + bindings, + types::{ARef ,AlwaysRefCounted ,Opaque }, +}; +
rust/kernel/mm.rs line 23
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+use core::{ + ops::Deref , + ptr::{self,NonNull }, +}; + +pub mod virt; + +/// A wrapper for the kernel's `struct mm_struct`. +/// +/// Since `mm_users` may be zero, the associated address space may not exist anymore. You must use
Can it also be the case that the space never existed to begin with? Then I would write "the associated address space may not exist."
Also I think it makes more sense to use "You can use [mmget_not_zero] to be able to access the address space." instead of the second sentence.
rust/kernel/mm.rs line 30
Quoted 7 lines
rust/kernel/mm.rs new file +7
-0+/// [`mmget_not_zero`] before accessing the address space. +/// +/// The `ARef<Mm>` smart pointer holds an `mmgrab` refcount. Its destructor may sleep. +/// +/// # Invariants +/// +/// Values of this type are always refcounted.
Would be good to record the refcount used in the invariant.
Quoted 17 lines
rust/kernel/mm.rs new file +17
-0+/// +/// [`mmget_not_zero`]: Mm::mmget_not_zero +pub struct Mm { + mm:Opaque <bindings::mm_struct >, +} + +// SAFETY: It is safe to call `mmdrop` on another thread than where `mmgrab` was called. +unsafe impl Send for Mm {} +// SAFETY: All methods on `Mm` can be called in parallel from several threads. +unsafe impl Sync for Mm {} + +// SAFETY: By the type invariants, this type is always refcounted. +unsafe impl AlwaysRefCounted for Mm { +fn inc_ref (&self) { +// SAFETY: The pointer is valid since self is a reference. +unsafe { bindings::mmgrab (self.as_raw ()) }; + }
rust/kernel/mm.rs line 57
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+ +unsafe fn dec_ref (obj:NonNull <Self >) { +// SAFETY: The caller is giving up their refcount. +unsafe { bindings::mmdrop (obj.cast ().as_ptr ()) }; + } +} + +/// A wrapper for the kernel's `struct mm_struct`. +/// +/// This type is used only when `mm_users` is known to be non-zero at compile-time. It can be used
I find the "This type is used only when" a bit weird, what about "Like an [Mm], but with non-zero mm_users."?
Quoted 35 lines
rust/kernel/mm.rs new file +35
-0+/// to access the associated address space. +/// +/// The `ARef<MmWithUser>` smart pointer holds an `mmget` refcount. Its destructor may sleep. +/// +/// # Invariants +/// +/// Values of this type are always refcounted. The value of `mm_users` is non-zero. +#[repr(transparent)] +pub struct MmWithUser { + mm:Mm , +} + +// SAFETY: It is safe to call `mmput` on another thread than where `mmget` was called. +unsafe impl Send for MmWithUser {} +// SAFETY: All methods on `MmWithUser` can be called in parallel from several threads. +unsafe impl Sync for MmWithUser {} + +// SAFETY: By the type invariants, this type is always refcounted. +unsafe impl AlwaysRefCounted for MmWithUser { +fn inc_ref (&self) { +// SAFETY: The pointer is valid since self is a reference. +unsafe { bindings::mmget (self.as_raw ()) }; + } + +unsafe fn dec_ref (obj:NonNull <Self >) { +// SAFETY: The caller is giving up their refcount. +unsafe { bindings::mmput (obj.cast ().as_ptr ()) }; + } +} + +// Make all `Mm` methods available on `MmWithUser`. +impl Deref for MmWithUser { +type Target =Mm ; + +#[inline]
rust/kernel/mm.rs line 102
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+fn deref (&self) -> &Mm { + &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.
Missing Invariants.
Quoted 58 lines
rust/kernel/mm.rs new file +58
-0+#[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 { +fn inc_ref (&self) { +// SAFETY: The pointer is valid since self is a reference. +unsafe { bindings::mmget (self.as_raw ()) }; + } + +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 { +/// Call `mmgrab` on `current.mm`. +#[inline] +pub fn mmgrab_current () ->Option <ARef <Mm >> { +// SAFETY: It's safe to get the `mm` field from current. +let mm =unsafe { +let current = bindings::get_current (); + (*current).mm + }; + +let mm =NonNull ::new (mm)?; + +// SAFETY: We just checked that `mm` is not null. +unsafe { bindings::mmgrab (mm.as_ptr ()) }; + +// SAFETY: We just created an `mmgrab` refcount. Layouts are compatible due to +// repr(transparent). +Some (unsafe {ARef ::from_raw (mm.cast ()) }) + } + +/// Returns a raw pointer to the inner `mm_struct`. +#[inline] +pub fn as_raw (&self) -> *mut bindings::mm_struct { + self.mm.get ()
rust/kernel/mm.rs line 170
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+ } + +/// Obtain a reference from a raw pointer. +/// +/// # Safety +/// +/// The caller must ensure that `ptr` points at an `mm_struct`, and that it is not deallocated +/// during the lifetime 'a. +#[inline] +pub unsafe fn from_raw_mm <'a>(ptr: *const bindings::mm_struct ) -> &'aMm {
Why not just from_raw?
---
Cheers,
Benno
Quoted 4 lines
rust/kernel/mm.rs new file +4
-0+// SAFETY: Caller promises that the pointer is valid for 'a. Layouts are compatible due to +// repr(transparent). +unsafe { &*ptr.cast () } + }
Alice Ryhl
maintainerQuoted 35 lines · Benno Lossin
Quoted 19 lines · Alice Ryhl
rust/kernel/mm.rs new file +13
-0@@ -0,0 +1,337 @@ +// SPDX-License-Identifier: GPL-2.0 + +// Copyright (C) 2024 Google LLC. + +//! Memory management. +//! +//! C header: [`include/linux/mm.h`](../../../../include/linux/mm.h) + +use crate ::{ + bindings, + types::{ARef ,AlwaysRefCounted ,Opaque }, +}; +rust/kernel/mm.rs line 23
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+use core::{ + ops::Deref , + ptr::{self,NonNull }, +}; + +pub mod virt; + +/// A wrapper for the kernel's `struct mm_struct`. +/// +/// Since `mm_users` may be zero, the associated address space may not exist anymore. You must use Can it also be the case that the space never existed to begin with? Then I would write "the associated address space may not exist."
Quoted 2 lines
Also I think it makes more sense to use "You can use [
mmget_not_zero] to be able to access the address space." instead of the second sentence.
I'm not sure if it can be the case that the space never existed, but I'll reword.
Quoted 9 lines
rust/kernel/mm.rs line 30
Quoted 7 lines
rust/kernel/mm.rs new file +7
-0+/// [`mmget_not_zero`] before accessing the address space. +/// +/// The `ARef<Mm>` smart pointer holds an `mmgrab` refcount. Its destructor may sleep. +/// +/// # Invariants +/// +/// Values of this type are always refcounted. Would be good to record the refcount used in the invariant.
Ok.
Quoted 22 lines
Quoted 22 lines
rust/kernel/mm.rs new file +22
-0+/// +/// [`mmget_not_zero`]: Mm::mmget_not_zero +pub struct Mm { + mm:Opaque <bindings::mm_struct >, +} + +// SAFETY: It is safe to call `mmdrop` on another thread than where `mmgrab` was called. +unsafe impl Send for Mm {} +// SAFETY: All methods on `Mm` can be called in parallel from several threads. +unsafe impl Sync for Mm {} + +// SAFETY: By the type invariants, this type is always refcounted. +unsafe impl AlwaysRefCounted for Mm { +fn inc_ref (&self) { +// SAFETY: The pointer is valid since self is a reference. +unsafe { bindings::mmgrab (self.as_raw ()) }; + } + +unsafe fn dec_ref (obj:NonNull <Self >) { +// SAFETY: The caller is giving up their refcount. +unsafe { bindings::mmdrop (obj.cast ().as_ptr ()) }; + }
Quoted 8 lines
rust/kernel/mm.rs line 57
Quoted 5 lines
rust/kernel/mm.rs new file +5
-0+} + +/// A wrapper for the kernel's `struct mm_struct`. +/// +/// This type is used only when `mm_users` is known to be non-zero at compile-time. It can be used I find the "This type is used only when" a bit weird, what about "Like an [
Mm], but with non-zeromm_users."?
Will reword.
Quoted 39 lines
Quoted 39 lines
rust/kernel/mm.rs new file +39
-0+/// to access the associated address space. +/// +/// The `ARef<MmWithUser>` smart pointer holds an `mmget` refcount. Its destructor may sleep. +/// +/// # Invariants +/// +/// Values of this type are always refcounted. The value of `mm_users` is non-zero. +#[repr(transparent)] +pub struct MmWithUser { + mm:Mm , +} + +// SAFETY: It is safe to call `mmput` on another thread than where `mmget` was called. +unsafe impl Send for MmWithUser {} +// SAFETY: All methods on `MmWithUser` can be called in parallel from several threads. +unsafe impl Sync for MmWithUser {} + +// SAFETY: By the type invariants, this type is always refcounted. +unsafe impl AlwaysRefCounted for MmWithUser { +fn inc_ref (&self) { +// SAFETY: The pointer is valid since self is a reference. +unsafe { bindings::mmget (self.as_raw ()) }; + } + +unsafe fn dec_ref (obj:NonNull <Self >) { +// SAFETY: The caller is giving up their refcount. +unsafe { bindings::mmput (obj.cast ().as_ptr ()) }; + } +} + +// Make all `Mm` methods available on `MmWithUser`. +impl Deref for MmWithUser { +type Target =Mm ; + +#[inline] +fn deref (&self) -> &Mm { + &self.mm + } +}
Quoted 8 lines
rust/kernel/mm.rs line 102
Quoted 6 lines
rust/kernel/mm.rs new file +6
-0+ +/// 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. Missing Invariants.
Hmm. Structs will inherit invariants from their fields, no?
Quoted 62 lines
Quoted 62 lines
rust/kernel/mm.rs new file +62
-0+#[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 { +fn inc_ref (&self) { +// SAFETY: The pointer is valid since self is a reference. +unsafe { bindings::mmget (self.as_raw ()) }; + } + +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 { +/// Call `mmgrab` on `current.mm`. +#[inline] +pub fn mmgrab_current () ->Option <ARef <Mm >> { +// SAFETY: It's safe to get the `mm` field from current. +let mm =unsafe { +let current = bindings::get_current (); + (*current).mm + }; + +let mm =NonNull ::new (mm)?; + +// SAFETY: We just checked that `mm` is not null. +unsafe { bindings::mmgrab (mm.as_ptr ()) }; + +// SAFETY: We just created an `mmgrab` refcount. Layouts are compatible due to +// repr(transparent). +Some (unsafe {ARef ::from_raw (mm.cast ()) }) + } + +/// Returns a raw pointer to the inner `mm_struct`. +#[inline] +pub fn as_raw (&self) -> *mut bindings::mm_struct { + self.mm.get () + } + +/// Obtain a reference from a raw pointer. +///
Quoted 8 lines
rust/kernel/mm.rs line 170
Quoted 6 lines
rust/kernel/mm.rs new file +6
-0+/// # Safety +/// +/// The caller must ensure that `ptr` points at an `mm_struct`, and that it is not deallocated +/// during the lifetime 'a. +#[inline] +pub unsafe fn from_raw_mm <'a>(ptr: *const bindings::mm_struct ) -> &'aMm {Why not just
from_raw?
See response to Danilo.
Alice
Quoted 11 lines · Alice Ryhl
Quoted 8 lines · Benno Lossin
rust/kernel/mm.rs line 102
Quoted 5 lines · Alice Ryhl
rust/kernel/mm.rs new file +5
-0+/// 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. Missing Invariants.
Hmm. Structs will inherit invariants from their fields, no?
No, usually the fields handle their invariants on their own, eg NonNull can only be constructed if the pointer is not null. But Refcounted structs are somewhat special in this regard, since you cannot construct them by-value. Thus if you build a new struct that contains them, then that also needs to be refcounted and have its own invariant to guarantee that the field still is refcounted.
---
Cheers,
Benno
Alice Ryhl
maintainerQuoted 35 lines · Benno Lossin
Quoted 19 lines · Alice Ryhl
rust/kernel/mm.rs new file +13
-0@@ -0,0 +1,337 @@ +// SPDX-License-Identifier: GPL-2.0 + +// Copyright (C) 2024 Google LLC. + +//! Memory management. +//! +//! C header: [`include/linux/mm.h`](../../../../include/linux/mm.h) + +use crate ::{ + bindings, + types::{ARef ,AlwaysRefCounted ,Opaque }, +}; +rust/kernel/mm.rs line 23
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+use core::{ + ops::Deref , + ptr::{self,NonNull }, +}; + +pub mod virt; + +/// A wrapper for the kernel's `struct mm_struct`. +/// +/// Since `mm_users` may be zero, the associated address space may not exist anymore. You must use Can it also be the case that the space never existed to begin with? Then I would write "the associated address space may not exist."
Quoted 2 lines
Also I think it makes more sense to use "You can use [
mmget_not_zero] to be able to access the address space." instead of the second sentence.
I took the "may not exist anymore" wording from the C side, so I'm going to keep it.
Alice
Danilo Krummrich
reviewerQuoted 37 lines · Alice Ryhl
This is a follow-up to the page abstractions [1] that were recently merged in 6.11. Rust Binder will need these abstractions to manipulate the vma in its implementation of the mmap fop on the Binder file.
This patch is based on Wedson's implementation on the old rust branch, but has been changed significantly. All mistakes are Alice's.
Co-developed-by Wedson Almeida Filho <[email protected]>Signed-off-by Wedson Almeida Filho <[email protected]>Signed-off-by Alice Ryhl <[email protected]>---
Changes in v3:
- Reorder entries inmm.rs.
- Use ARef formmput_asynchelper.
- Clarify that VmArea requires you to hold the mmap read or write lock.
- Link to v2: https://lore.kernel.org/r/[email protected]Changes in v2:
-mm.rsis redesigned from scratch making use of AsRef
- Add notes about whether destructors may sleep
- Rename Area to VmArea
- Link to v1: https://lore.kernel.org/r/[email protected]--- rust/helpers.c | 61 +++++++++ rust/kernel/lib.rs | 1 + rust/kernel/mm.rs | 337 +++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/mm/virt.rs | 204 ++++++++++++++++++++++++++++++ rust/kernel/types.rs | 9 ++ 5 files changed, 612 insertions(+)rust/kernel/mm.rs new file +0
-0
rust/kernel/mm.rs line 7
Quoted 7 lines
rust/kernel/mm.rs new file +7
-0@@ -0,0 +1,337 @@ +// SPDX-License-Identifier: GPL-2.0 + +// Copyright (C) 2024 Google LLC. + +//! Memory management. +//! +//! C header: [`include/linux/mm.h`](../../../../include/linux/mm.h)
NIT: srctree
Quoted 5 lines
rust/kernel/mm.rs new file +5
-0+ +/// Returns a raw pointer to the inner `mm_struct`. +#[inline] +pub fn as_raw (&self) -> *mut bindings::mm_struct { + self.mm.get ()
rust/kernel/mm.rs line 170
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+ } + +/// Obtain a reference from a raw pointer. +/// +/// # Safety +/// +/// The caller must ensure that `ptr` points at an `mm_struct`, and that it is not deallocated +/// during the lifetime 'a. +#[inline] +pub unsafe fn from_raw_mm <'a>(ptr: *const bindings::mm_struct ) -> &'aMm {
I'd just call this from_raw, like you call the counterpart as_raw above. Same goes for MmWithUser and VmArea.
Quoted 7 lines
rust/kernel/types.rs +0
-0@@ -366,6 +366,15 @@ pub unsafe fn from_raw(ptr: NonNull<T>) -> Self { _p: PhantomData, }
rust/kernel/types.rs pub unsafe fn from_raw(ptr: NonNull<T>) -> Self { · line 377
Quoted 10 lines
rust/kernel/types.rs +9
-0} + +/// Pass ownership of the refcount to a raw pointer. +pub fn into_raw (self) ->NonNull <T > { +let ptr = self.ptr; +// Skip the destructor. + core::mem::forget (self); + + ptr + }
I think this should be a separate patch.
Quoted 13 lines
rust/kernel/types.rs +0
-1}impl <T :AlwaysRefCounted >Clone for ARef <T > { ---base-commit:
8400291e289ee6b2bf9779ff1c83a291501f017b
change-id: 20240723-vma-f80119f9fb35Best regards,
Signature · 1 line
Alice Ryhl <[email protected]>
Alice Ryhl
maintainerQuoted 33 lines · Danilo Krummrich
Quoted 31 lines · Alice Ryhl
This is a follow-up to the page abstractions [1] that were recently merged in 6.11. Rust Binder will need these abstractions to manipulate the vma in its implementation of the mmap fop on the Binder file.
This patch is based on Wedson's implementation on the old rust branch, but has been changed significantly. All mistakes are Alice's.
Co-developed-by Wedson Almeida Filho <[email protected]>Signed-off-by Wedson Almeida Filho <[email protected]>Signed-off-by Alice Ryhl <[email protected]>---
Changes in v3:
- Reorder entries inmm.rs.
- Use ARef formmput_asynchelper.
- Clarify that VmArea requires you to hold the mmap read or write lock.
- Link to v2: https://lore.kernel.org/r/[email protected]Changes in v2:
-mm.rsis redesigned from scratch making use of AsRef
- Add notes about whether destructors may sleep
- Rename Area to VmArea
- Link to v1: https://lore.kernel.org/r/[email protected]--- rust/helpers.c | 61 +++++++++ rust/kernel/lib.rs | 1 + rust/kernel/mm.rs | 337 +++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/mm/virt.rs | 204 ++++++++++++++++++++++++++++++ rust/kernel/types.rs | 9 ++ 5 files changed, 612 insertions(+)
Quoted 15 lines
rust/kernel/mm.rs line 7
Quoted 13 lines
rust/kernel/mm.rs new file +7
-0@@ -0,0 +1,337 @@ +// SPDX-License-Identifier: GPL-2.0 + +// Copyright (C) 2024 Google LLC. + +//! Memory management. +//! +//! C header: [`include/linux/mm.h`](../../../../include/linux/mm.h) NIT: srctree
Ah, thanks. Good catch.
Quoted 10 lines
Quoted 10 lines
rust/kernel/mm.rs new file +10
-0+ +/// Returns a raw pointer to the inner `mm_struct`. +#[inline] +pub fn as_raw (&self) -> *mut bindings::mm_struct { + self.mm.get () + } + +/// Obtain a reference from a raw pointer. +/// +/// # Safety
Quoted 8 lines
rust/kernel/mm.rs line 170
Quoted 5 lines
rust/kernel/mm.rs new file +5
-0+/// +/// The caller must ensure that `ptr` points at an `mm_struct`, and that it is not deallocated +/// during the lifetime 'a. +#[inline] +pub unsafe fn from_raw_mm <'a>(ptr: *const bindings::mm_struct ) -> &'aMm {I'd just call this
from_raw, like you call the counterpartas_rawabove. Same goes forMmWithUserandVmArea.
I've been using this naming convention since this discussion:
https://lore.kernel.org/all/20240401-marge-gepaukt-9a1972c848d9@brauner/
Quoted 11 lines
Quoted 11 lines
rust/kernel/types.rs +3
-0@@ -366,6 +366,15 @@ pub unsafe fn from_raw(ptr: NonNull<T>) -> Self { _p: PhantomData, } } + +/// Pass ownership of the refcount to a raw pointer. +pub fn into_raw (self) ->NonNull <T > {
Quoted 8 lines
rust/kernel/types.rs pub unsafe fn from_raw(ptr: NonNull<T>) -> Self { · line 377
Quoted 6 lines
rust/kernel/types.rs +6
-0+let ptr = self.ptr; +// Skip the destructor. + core::mem::forget (self); + + ptr + }I think this should be a separate patch.
Sure.
Alice