"Danilo Krummrich" <[email protected]> writes:
> From: Gary Guo <[email protected]>
>
> These constructors create a coherent container of a single object
> instead of slice. They are named `zeroed` and `zeroed_with_attrs` to
> emphasis that they are created initialized zeroed. It is intended that
> there'll be new constructors that take `PinInit` instead of zeroing.
>
> Signed-off-by: Gary Guo <[email protected]>
> Reviewed-by: Alice Ryhl <[email protected]>
> Signed-off-by: Danilo Krummrich <[email protected]>
> ---
> rust/kernel/dma.rs | 81 ++++++++++++++++++++++++++++++++++++----
> samples/rust/rust_dma.rs | 8 ++--
> 2 files changed, 77 insertions(+), 12 deletions(-)
>
> diff --git a/rust/kernel/dma.rs b/rust/kernel/dma.rs
> index ff3e147f1a23..db645b01bdd0 100644
> --- a/rust/kernel/dma.rs
> +++ b/rust/kernel/dma.rs
> @@ -47,7 +47,7 @@ pub trait Device: AsRef<device::Device<Core>> {
> /// # Safety
> ///
> /// This method must not be called concurrently with any DMA allocation
> or mapping primitives,
> - /// such as [`CoherentAllocation::alloc_attrs`].
> + /// such as [`Coherent::zeroed`].
> unsafe fn dma_set_mask(&self, mask: DmaMask) -> Result {
> // SAFETY:
> // - By the type invariant of `device::Device`,
> `self.as_ref().as_raw()` is valid.
> @@ -64,7 +64,7 @@ unsafe fn dma_set_mask(&self, mask: DmaMask) -> Result {
> /// # Safety
> ///
> /// This method must not be called concurrently with any DMA allocation
> or mapping primitives,
> - /// such as [`CoherentAllocation::alloc_attrs`].
> + /// such as [`Coherent::zeroed`].
> unsafe fn dma_set_coherent_mask(&self, mask: DmaMask) -> Result {
> // SAFETY:
> // - By the type invariant of `device::Device`,
> `self.as_ref().as_raw()` is valid.
> @@ -83,7 +83,7 @@ unsafe fn dma_set_coherent_mask(&self, mask: DmaMask) ->
> Result {
> /// # Safety
> ///
> /// This method must not be called concurrently with any DMA allocation
> or mapping primitives,
> - /// such as [`CoherentAllocation::alloc_attrs`].
> + /// such as [`Coherent::zeroed`].
> unsafe fn dma_set_mask_and_coherent(&self, mask: DmaMask) -> Result {
> // SAFETY:
> // - By the type invariant of `device::Device`,
> `self.as_ref().as_raw()` is valid.
> @@ -102,7 +102,7 @@ unsafe fn dma_set_mask_and_coherent(&self, mask: DmaMask)
> -> Result {
> /// # Safety
> ///
> /// This method must not be called concurrently with any DMA allocation
> or mapping primitives,
> - /// such as [`CoherentAllocation::alloc_attrs`].
> + /// such as [`Coherent::zeroed`].
> unsafe fn dma_set_max_seg_size(&self, size: u32) {
> // SAFETY:
> // - By the type invariant of `device::Device`,
> `self.as_ref().as_raw()` is valid.
> @@ -202,12 +202,12 @@ pub const fn value(&self) -> u64 {
> ///
> /// ```
> /// # use kernel::device::{Bound, Device};
> -/// use kernel::dma::{attrs::*, CoherentAllocation};
> +/// use kernel::dma::{attrs::*, Coherent};
> ///
> /// # fn test(dev: &Device<Bound>) -> Result {
> /// let attribs = DMA_ATTR_FORCE_CONTIGUOUS | DMA_ATTR_NO_WARN;
> -/// let c: CoherentAllocation<u64> =
> -/// CoherentAllocation::alloc_attrs(dev, 4, GFP_KERNEL, attribs)?;
> +/// let c: Coherent<[u64]> =
> +/// Coherent::zeroed_slice_with_attrs(dev, 4, GFP_KERNEL, attribs)?;
> /// # Ok::<(), Error>(()) }
> /// ```
> #[derive(Clone, Copy, PartialEq)]
> @@ -492,7 +492,6 @@ pub unsafe fn field_write<F: AsBytes>(&self, field: *mut
> F, val: F) {
>
> impl<T: AsBytes + FromBytes> Coherent<T> {
> /// Allocates a region of `T` of coherent memory.
> - #[expect(unused)]
> fn alloc_with_attrs(
> dev: &device::Device<Bound>,
> gfp_flags: kernel::alloc::Flags,
> @@ -529,6 +528,35 @@ fn alloc_with_attrs(
> })
> }
>
> + /// Allocates a region of type `T` of coherent memory.
For consistency "Allocates a ZEROED region...".
> + ///
> + /// # Examples
> + ///
> + /// ```
> + /// # use kernel::device::{Bound, Device};
> + /// use kernel::dma::{attrs::*, Coherent};
> + ///
> + /// # fn test(dev: &Device<Bound>) -> Result {
> + /// let c: Coherent<[u64; 4]> =
> + /// Coherent::zeroed_with_attrs(dev, GFP_KERNEL, DMA_ATTR_NO_WARN)?;
> + /// # Ok::<(), Error>(()) }
> + /// ```
> + #[inline]
> + pub fn zeroed_with_attrs(
> + dev: &device::Device<Bound>,
> + gfp_flags: kernel::alloc::Flags,
> + dma_attrs: Attrs,
> + ) -> Result<Self> {
> + Self::alloc_with_attrs(dev, gfp_flags | __GFP_ZERO, dma_attrs)
> + }
> +
> + /// Performs the same functionality as [`Coherent::zeroed_with_attrs`],
> except the
> + /// `dma_attrs` is 0 by default.
> + #[inline]
> + pub fn zeroed(dev: &device::Device<Bound>, gfp_flags:
> kernel::alloc::Flags) -> Result<Self> {
> + Self::zeroed_with_attrs(dev, gfp_flags, Attrs(0))
> + }
> +
> /// Allocates a region of `[T; len]` of coherent memory.
> fn alloc_slice_with_attrs(
> dev: &device::Device<Bound>,
> @@ -572,6 +600,43 @@ fn alloc_slice_with_attrs(
> dma_attrs,
> })
> }
> +
> + /// Allocates a zeroed region of type `T` of coherent memory.
Should it be "of type `[T]`"?
Best regards,
Andreas Hindborg
