Fixes the stack overflow
Subsystems (7)
v4 cover Fixes the stack overflow
---
Changes in v4:
- Rebase on top of projection changes
- Use index projection when writing PTEs
- Keep PteArray, as discussed in V2, and move entry calculation there
- Avoid stack allocation by writing PTEs directly to DMA memory
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Addressed the comments and re-instated the PteArray type.
- PteArray now uses init instead of new where it writes to self page by page.
- PteArray just needs a pte pointer obtained from the gsp_mem.as_slice_mut.
I hope I understood everything in the V2 email chain and implemented it correctly :)
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Missed a code formatting issue.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Gary Guo (3):
rust: ptr: add KnownSize trait to support DST size info extraction
rust: ptr: add projection infrastructure
rust: dma: use pointer projection infra for dma_{read,write} macro
Tim Kovalenko (1):
gpu: nova-core: fix stack overflow in GSP memory allocation
drivers/gpu/nova-core/gsp.rs | 48 ++++--- drivers/gpu/nova-core/gsp/boot.rs | 2 +- drivers/gpu/nova-core/gsp/cmdq.rs | 23 ++- rust/kernel/dma.rs | 114 +++++++-------- rust/kernel/lib.rs | 4 + rust/kernel/ptr.rs | 30 +++- rust/kernel/ptr/projection.rs | 294 ++++++++++++++++++++++++++++++++++++++ samples/rust/rust_dma.rs | 30 ++-- scripts/Makefile.build | 4 +- 9 files changed, 443 insertions(+), 106 deletions(-)
---
base-commit: dd8a93dafe6ef50b49d2a7b44862264d74a7aafa
change-id: 20260212-drm-rust-next-beb92aee9d75
Best regards,
Signature · 1 line
Tim Kovalenko <[email protected]>
PATCH v4 1/4 rust: ptr: add `KnownSize` trait to support DST size info extraction
From: Gary Guo <[email protected]>
Add a KnownSize trait which is used obtain a size from a raw pointer's metadata. This makes it possible to obtain size information on a raw slice pointer. This is similar to Rust core::mem::size_of_val_raw which is not yet stable.
--- rust/kernel/lib.rs | 1 + rust/kernel/ptr.rs | 27 ++++++++++++++++++++++++++- 2 files changed, 27 insertions(+), 1 deletion(-)
rust/kernel/lib.rs +1 -0
@@ -20,6 +20,7 @@#![feature(generic_nonzero)] #![feature(inline_const)] #![feature(pointer_is_aligned)] +#![feature(slice_ptr_len)] // // Stable since Rust 1.80.0. #![feature(slice_flatten)]
rust/kernel/ptr.rs +26 -1
@@ -2,7 +2,10 @@//! Types and functions to work with pointers and addresses. -use core::mem::align_of; +use core::mem::{ + align_of, + size_of,// +};use core::num::NonZero ;/// Type representing an alignment, which is always a power of two.
@@ -225,3 +228,25 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Trait to represent compile-time known size information. +/// +/// This is a generalization of what [`size_of`] which works for dynamically sized types. +pub trait KnownSize { +/// Get the size of an object of this type in bytes, with the metadata of the given pointer. +fn size (p: *const Self ) ->usize ; +} + +impl <T >KnownSize for T { +#[inline(always)] +fn size (_: *const Self ) ->usize { +size_of ::<T >() + } +} + +impl <T >KnownSize for [T ] { +#[inline(always)] +fn size (p: *const Self ) ->usize { + p.len () *size_of ::<T >() + } +}
Signature · 1 line
2.53.0
PATCH v4 2/4 rust: ptr: add projection infrastructure
In reply to Tim KovalenkoFrom: Gary Guo <[email protected]>
Add a generic infrastructure for performing field and index projections on raw pointers. This will form the basis of performing I/O projections.
Pointers manipulations are intentionally using the safe wrapping variants instead of the unsafe variants, as the latter requires pointers to be inside an allocation which is not necessarily true for I/O pointers.
This projection macro protects against rogue Deref implementation, which can causes the projected pointer to be outside the bounds of starting pointer. This is extremely unlikely and Rust has a lint to catch this, but is unsoundness regardless. The protection works by inducing type inference ambiguity when Deref is implemented.
This projection macro also stops projecting into unaligned fields (i.e. fields of #[repr(packed)] structs), as misaligned pointers require special handling. This is implemented by attempting to create reference to projected field inside a if false block. Despite being unreachable, Rust still checks that they're not unaligned fields.
The projection macro supports both fallible and infallible index projections. These are described in detail inside the documentation.
--- rust/kernel/lib.rs | 3 + rust/kernel/ptr.rs | 3 + rust/kernel/ptr/projection.rs | 294 ++++++++++++++++++++++++++++++++++++++++++ scripts/Makefile.build | 4 +- 4 files changed, 303 insertions(+), 1 deletion(-)
rust/kernel/lib.rs +3 -0
@@ -38,6 +38,9 @@#![feature(const_ptr_write)] #![feature(const_refs_to_cell)] // +// Stable since Rust 1.84.0. +#![feature(strict_provenance)] +// // Expected to become stable. #![feature(arbitrary_self_types)] //
rust/kernel/ptr.rs +3 -0
@@ -2,6 +2,9 @@//! Types and functions to work with pointers and addresses. +pub mod projection; +pub use crate ::project_pointeras project; +use core::mem::{ align_of, size_of,//
rust/kernel/ptr/projection.rs new file +294 -0
294 lines not on this page · raw message
scripts/Makefile.build +3 -1
@@ -310,16 +310,18 @@ $(obj)/%.lst: $(obj)/%.c FORCE # The features in this list are the ones allowed for non-`rust/` code. # +# - Stable since Rust 1.79.0: `feature(slice_ptr_len)`. # - Stable since Rust 1.81.0: `feature(lint_reasons)`. # - Stable since Rust 1.82.0: `feature(asm_const)`, # `feature(offset_of_nested)`, `feature(raw_ref_op)`. +# - Stable since Rust 1.84.0: `feature(strict_provenance)`. # - Stable since Rust 1.87.0: `feature(asm_goto)`. # - Expected to become stable: `feature(arbitrary_self_types)`. # - To be determined: `feature(used_with_arg)`. # # Please see https://github.com/Rust-for-Linux/linux/issues/2 for details on # the unstable features in use. -rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,lint_reasons,offset_of_nested,raw_ref_op,used_with_arg +rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,lint_reasons,offset_of_nested,raw_ref_op,slice_ptr_len,strict_provenance,used_with_arg # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree
Signature · 1 line
2.53.0
PATCH v4 3/4 rust: dma: use pointer projection infra for `dma_{read,write}` macro
In reply to Tim KovalenkoFrom: Gary Guo <[email protected]>
Current dma_read!, dma_write! macros also use a custom addr_of!()-based implementation for projecting pointers, which has soundness issue as it relies on absence of Deref implementation on types. It also has a soundness issue where it does not protect against unaligned fields (when #[repr(packed)] is used) so it can generate misaligned accesses.
This commit migrates them to use the general pointer projection infrastructure, which handles these cases correctly.
As part of migration, the macro is updated to have an improved surface syntax. The current macro have
dma_read!(a.b.c[d].e.f)
to mean a.b.c is a DMA coherent allocation and it should project into it with [d].e.f and do a read, which is confusing as it makes the indexing operator integral to the macro (so it will break if you have an array of CoherentAllocation, for example).
This also is problematic as we would like to generalize CoherentAllocation from just slices to arbitrary types.
Make the macro expects dma_read!(path.to.dma, .path.inside.dma) as the canonical syntax. The index operator is no longer special and is just one type of projection (in additional to field projection). Similarly, make dma_write!(path.to.dma, .path.inside.dma, value) become the canonical syntax for writing.
Another issue of the current macro is that it is always fallible. This makes sense with existing design of CoherentAllocation, but once we support fixed size arrays with CoherentAllocation, it is desirable to have the ability to perform infallible indexing as well, e.g. doing a [0] index of [Foo; 2] is okay and can be checked at build-time, so forcing falliblity is non-ideal. To capture this, the macro is changed to use [idx] as infallible projection and [idx]? as fallible index projection (those syntax are part of the general projection infra). A benefit of this is that while individual indexing operation may fail, the overall read/write operation is not fallible.
--- drivers/gpu/nova-core/gsp.rs | 14 ++--- drivers/gpu/nova-core/gsp/boot.rs | 2 +- drivers/gpu/nova-core/gsp/cmdq.rs | 10 +++- rust/kernel/dma.rs | 114 +++++++++++++++++--------------------- samples/rust/rust_dma.rs | 30 +++++----- 5 files changed, 81 insertions(+), 89 deletions(-)
drivers/gpu/nova-core/gsp.rs +7 -7
@@ -143,14 +143,14 @@ pub(crate) fn new(pdev: &pci::Device<device::Bound>) -> impl PinInit<Self, Error// _kgspInitLibosLoggingStructures (allocates memory for buffers) // kgspSetupLibosInitArgs_IMPL (creates pLibosInitArgs[] array) dma_write! ( - libos[0 ] =LibosMemoryRegionInitArgument ::new ("LOGINIT" , &loginit.0 ) - )?; + libos, [0 ]?,LibosMemoryRegionInitArgument ::new ("LOGINIT" , &loginit.0 ) + );dma_write! ( - libos[1 ] =LibosMemoryRegionInitArgument ::new ("LOGINTR" , &logintr.0 ) - )?; -dma_write! (libos[2 ] =LibosMemoryRegionInitArgument ::new ("LOGRM" , &logrm.0 ))?; -dma_write! (rmargs[0 ].inner = fw::GspArgumentsCached ::new (cmdq))?; -dma_write! (libos[3 ] =LibosMemoryRegionInitArgument ::new ("RMARGS" , rmargs))?; + libos, [1 ]?,LibosMemoryRegionInitArgument ::new ("LOGINTR" , &logintr.0 ) + ); +dma_write! (libos, [2 ]?,LibosMemoryRegionInitArgument ::new ("LOGRM" , &logrm.0 )); +dma_write! (rmargs, [0 ]?.inner, fw::GspArgumentsCached ::new (cmdq)); +dma_write! (libos, [3 ]?,LibosMemoryRegionInitArgument ::new ("RMARGS" , rmargs)); }, })) })
drivers/gpu/nova-core/gsp/boot.rs +1 -1
@@ -166,7 +166,7 @@ pub(crate) fn boot(let wpr_meta =CoherentAllocation ::<GspFwWprMeta >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (wpr_meta[0 ] =GspFwWprMeta ::new (&gsp_fw, &fb_layout))?; +dma_write! (wpr_meta, [0 ]?,GspFwWprMeta ::new (&gsp_fw, &fb_layout)); self.cmdq .send_command (bar, commands::SetSystemInfo ::new (pdev))?;
drivers/gpu/nova-core/gsp/cmdq.rs +7 -3
@@ -202,9 +202,13 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem[0 ].ptes =PteArray ::new (gsp_mem.dma_handle ())?)?; -dma_write! (gsp_mem[0 ].cpuq.tx =MsgqTxHeader ::new (MSGQ_SIZE ,RX_HDR_OFF ,MSGQ_NUM_PAGES ))?; -dma_write! (gsp_mem[0 ].cpuq.rx =MsgqRxHeader ::new ())?; +dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); +dma_write! ( + gsp_mem, + [0 ]?.cpuq.tx, +MsgqTxHeader ::new (MSGQ_SIZE ,RX_HDR_OFF ,MSGQ_NUM_PAGES ) + ); +dma_write! (gsp_mem, [0 ]?.cpuq.rx,MsgqRxHeader ::new ());Ok (Self (gsp_mem)) }
rust/kernel/dma.rs +50 -64
158 lines not on this page · raw message
samples/rust/rust_dma.rs +16 -14
@@ -68,7 +68,7 @@ fn probe(pdev: &pci::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, ECoherentAllocation ::alloc_coherent (pdev.as_ref (),TEST_VALUES .len (),GFP_KERNEL )?;for (i, value)in TEST_VALUES .into_iter ().enumerate () { - kernel::dma_write!(ca[i] =MyStruct ::new (value.0 , value.1 ))?; + kernel::dma_write!(ca, [i]?,MyStruct ::new (value.0 , value.1 )); }let size =4 * page::PAGE_SIZE ;
@@ -85,24 +85,26 @@ fn probe(pdev: &pci::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, E } } +impl DmaSampleDriver { +fn check_dma (&self) ->Result { +for (i, value)in TEST_VALUES .into_iter ().enumerate () { +let val0 = kernel::dma_read!(self.ca, [i]?.h); +let val1 = kernel::dma_read!(self.ca, [i]?.b); + +assert_eq! (val0, value.0 ); +assert_eq! (val1, value.1 ); + } + +Ok (()) + } +} +#[pinned_drop] impl PinnedDrop for DmaSampleDriver {fn drop (self:Pin <&mut Self >) {dev_info! (self.pdev,"Unload DMA test driver.\n" ); -for (i, value)in TEST_VALUES .into_iter ().enumerate () { -let val0 = kernel::dma_read!(self.ca[i].h); -let val1 = kernel::dma_read!(self.ca[i].b); -assert! (val0.is_ok ()); -assert! (val1.is_ok ()); - -if let Ok (val0) = val0 { -assert_eq! (val0, value.0 ); - } -if let Ok (val1) = val1 { -assert_eq! (val1, value.1 ); - } - } +assert! (self.check_dma ().is_ok ());for (i, entry)in self.sgt.iter ().enumerate () {dev_info! (
Signature · 1 line
2.53.0
PATCH v4 4/4 gpu: nova-core: fix stack overflow in GSP memory allocation
In reply to Tim KovalenkoThe Cmdq::new function was allocating a PteArray struct on the stack and was causing a stack overflow with 8216 bytes.
Modify the PteArray to calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.
--- drivers/gpu/nova-core/gsp.rs | 34 +++++++++++++++++++--------------- drivers/gpu/nova-core/gsp/cmdq.rs | 15 ++++++++++++++- 2 files changed, 33 insertions(+), 16 deletions(-)
drivers/gpu/nova-core/gsp.rs +19 -15
@@ -47,16 +47,11 @@unsafe impl <const NUM_ENTRIES :usize >AsBytes for PteArray <NUM_ENTRIES > {}impl <const NUM_PAGES :usize >PteArray <NUM_PAGES > { -/// Creates a new page table array mapping `NUM_PAGES` GSP pages starting at address `start`. -fn new (start:DmaAddress ) ->Result <Self > { -let mut ptes = [0u64 ;NUM_PAGES ]; -for (i, pte)in ptes.iter_mut ().enumerate () { - *pte = start - .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) - .ok_or (EOVERFLOW )?; - } - -Ok (Self (ptes)) +/// Returns the page table entry for `index`, for a mapping starting at `start` DmaAddress. +fn entry (start:DmaAddress , index:usize ) ->Result <u64 > { + start + .checked_add (num::usize_as_u64 (index) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW ) } }
@@ -86,16 +81,25 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { NUM_PAGES * GSP_PAGE_SIZE, GFP_KERNEL | __GFP_ZERO, )?); -let ptes =PteArray ::<NUM_PAGES >::new (obj.0 .dma_handle ())?; + +let start_addr = obj.0 .dma_handle ();// SAFETY: `obj` has just been created and we are its sole user. -unsafe { -// Copy the self-mapping PTE at the expected location. +let pte_region =unsafe { obj.0 - .as_slice_mut (size_of ::<u64 >(),size_of_val (&ptes))? - .copy_from_slice (ptes.as_bytes ()) + .as_slice_mut (size_of ::<u64 >(),NUM_PAGES *size_of ::<u64 >())? }; +// This is a one by one GSP Page write to the memory +// to avoid stack overflow when allocating the whole array at once. +for (i, chunk)in pte_region.chunks_exact_mut (size_of ::<u64 >()).enumerate () { +let pte_value = start_addr + .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW )?; + + chunk.copy_from_slice (&pte_value.to_ne_bytes ()); + } +Ok (obj) } }
drivers/gpu/nova-core/gsp/cmdq.rs +14 -1
@@ -202,7 +202,20 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); + +const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); + +let start = gsp_mem.dma_handle (); +// One by one GSP Page write to the memory to avoid stack overflow when allocating +// the whole array at once. +for iin 0 ..NUM_PTES { +dma_write! ( + gsp_mem, + [0 ]?.ptes.0 [i], +PteArray ::<NUM_PTES >::entry (start, i)? + ); + } +dma_write! ( gsp_mem, [0 ]?.cpuq.tx,
Signature · 1 line
2.53.0
Danilo Krummrich
maintainerRe: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
Quoted 9 lines · On Mon Mar 9, 2026 at 5:34 PM CET, Tim Kovalenko via B4 Relay wrote:
From: Tim Kovalenko <[email protected]>
The
Cmdq::newfunction was allocating aPteArraystruct on the stack and was causing a stack overflow with 8216 bytes.Modify the
PteArrayto calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.
Quoted 1 line
Signed-off-by Tim Kovalenko <[email protected]>
A few nits below, but I can fix them up [1] on apply.
Review
Quoted 4 lines
(quoted diff) +4
-0+ for (i, chunk) in pte_region.chunks_exact_mut(size_of::<u64>()).enumerate() { + let pte_value = start_addr + .checked_add(num::usize_as_u64(i) << GSP_PAGE_SHIFT) + .ok_or(EOVERFLOW)?;
This should use PteArray::entry().
It would also be nice to get rid of the unsafe {} and use dma_write!() instead, but this can be a follow-up patch.
Quoted 12 lines
(quoted diff) +4
-0+ + chunk.copy_from_slice(&pte_value.to_ne_bytes()); + } + Ok(obj) } }drivers/gpu/nova-core/gsp/cmdq.rs +0
-0
drivers/gpu/nova-core/gsp/cmdq.rs fn new(dev: &device::Device<device::Bound>) -> Result<Self> { · line 206
Quoted 6 lines
drivers/gpu/nova-core/gsp/cmdq.rs +2
-1@@ -202,7 +202,20 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); + +const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >();
We can avoid duplicating this by making it a constant of GspMem.
drivers/gpu/nova-core/gsp/cmdq.rs fn new(dev: &device::Device<device::Bound>) -> Result<Self> { · line 216
Quoted 10 lines
drivers/gpu/nova-core/gsp/cmdq.rs +10
-0+let start = gsp_mem.dma_handle (); +// One by one GSP Page write to the memory to avoid stack overflow when allocating +// the whole array at once. +for iin 0 ..NUM_PTES { +dma_write! ( + gsp_mem, + [0 ]?.ptes.0 [i], +PteArray ::<NUM_PTES >::entry (start, i)? + ); + }
-- [1] --
drivers/gpu/nova-core/gsp.rs +3 -5
@@ -48,6 +48,7 @@ unsafe impl<const NUM_ENTRIES: usize> AsBytes for PteArray<NUM_ENTRIES> {}impl <const NUM_PAGES :usize >PteArray <NUM_PAGES > {/// Returns the page table entry for `index`, for a mapping starting at `start` DmaAddress. +// TODO: Replace with `IoView` projection once available. fn entry (start:DmaAddress , index:usize ) ->Result <u64 > { start .checked_add (num::usize_as_u64 (index) <<GSP_PAGE_SHIFT )
@@ -90,12 +91,9 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { .as_slice_mut(size_of::<u64>(), NUM_PAGES * size_of::<u64>())? }; -// This is a one by one GSP Page write to the memory -// to avoid stack overflow when allocating the whole array at once. +// Write values one by one to avoid an on-stack instance of `PteArray`. for (i, chunk)in pte_region.chunks_exact_mut (size_of ::<u64 >()).enumerate () { -let pte_value = start_addr - .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) - .ok_or (EOVERFLOW )?; +let pte_value =PteArray ::<NUM_PAGES >::entry (start_addr, i)?; chunk.copy_from_slice (&pte_value.to_ne_bytes ()); }
drivers/gpu/nova-core/gsp/cmdq.rs +7 -5
@@ -159,7 +159,7 @@ struct Msgq {#[repr( C )] struct GspMem {/// Self-mapping page table entries. - ptes:PteArray <{GSP_PAGE_SIZE /size_of ::<u64 >() }>, + ptes:PteArray <{Self ::PTE_ARRAY_SIZE }>,/// CPU queue: the driver writes commands here, and the GSP reads them. It also contains the /// write and read pointers that the CPU updates. ///
@@ -172,6 +172,10 @@ struct GspMem { gspq: Msgq, } +impl GspMem { +const PTE_ARRAY_SIZE :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); +} +// SAFETY: These structs don't meet the no-padding requirements of AsBytes but // that is not a problem because they are not used outside the kernel. unsafe impl AsBytes for GspMem {}
@@ -202,16 +206,14 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); -let start = gsp_mem.dma_handle ();// One by one GSP Page write to the memory to avoid stack overflow when allocating // the whole array at once. -for iin 0 ..NUM_PTES { +for iin 0 ..GspMem ::PTE_ARRAY_SIZE {dma_write! ( gsp_mem, [0 ]?.ptes.0 [i], -PteArray ::<NUM_PTES >::entry (start, i)? +PteArray ::<{GspMem ::PTE_ARRAY_SIZE }>::entry (start, i)? ); }
Re: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
Quoted 4 lines · Danilo Krummrich
Reported-by Gary Guo <[email protected]>Fixes f38b4f105cfc ("gpu: nova-core: Create initial Gsp")
objtool also complains about it because it doesn't handle certain instructions, so probably:
Cheers,
Miguel
Re: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
In reply to Tim KovalenkoQuoted 82 lines · On Tue Mar 10, 2026 at 1:34 AM JST, Tim Kovalenko via B4 Relay wrote:
From: Tim Kovalenko <[email protected]>
The
Cmdq::newfunction was allocating aPteArraystruct on the stack and was causing a stack overflow with 8216 bytes.Modify the
PteArrayto calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.Signed-off-by Tim Kovalenko <[email protected]>--- drivers/gpu/nova-core/gsp.rs | 34 +++++++++++++++++++--------------- drivers/gpu/nova-core/gsp/cmdq.rs | 15 ++++++++++++++- 2 files changed, 33 insertions(+), 16 deletions(-)drivers/gpu/nova-core/gsp.rs +19
-15@@ -47,16 +47,11 @@unsafe impl <const NUM_ENTRIES :usize >AsBytes for PteArray <NUM_ENTRIES > {}impl <const NUM_PAGES :usize >PteArray <NUM_PAGES > { -/// Creates a new page table array mapping `NUM_PAGES` GSP pages starting at address `start`. -fn new (start:DmaAddress ) ->Result <Self > { -let mut ptes = [0u64 ;NUM_PAGES ]; -for (i, pte)in ptes.iter_mut ().enumerate () { - *pte = start - .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) - .ok_or (EOVERFLOW )?; - } - -Ok (Self (ptes)) +/// Returns the page table entry for `index`, for a mapping starting at `start` DmaAddress. +fn entry (start:DmaAddress , index:usize ) ->Result <u64 > { + start + .checked_add (num::usize_as_u64 (index) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW ) } }@@ -86,16 +81,25 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { NUM_PAGES * GSP_PAGE_SIZE, GFP_KERNEL | __GFP_ZERO, )?); -let ptes =PteArray ::<NUM_PAGES >::new (obj.0 .dma_handle ())?; + +let start_addr = obj.0 .dma_handle ();// SAFETY: `obj` has just been created and we are its sole user. -unsafe { -// Copy the self-mapping PTE at the expected location. +let pte_region =unsafe { obj.0 - .as_slice_mut (size_of ::<u64 >(),size_of_val (&ptes))? - .copy_from_slice (ptes.as_bytes ()) + .as_slice_mut (size_of ::<u64 >(),NUM_PAGES *size_of ::<u64 >())? }; +// This is a one by one GSP Page write to the memory +// to avoid stack overflow when allocating the whole array at once. +for (i, chunk)in pte_region.chunks_exact_mut (size_of ::<u64 >()).enumerate () { +let pte_value = start_addr + .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW )?; + + chunk.copy_from_slice (&pte_value.to_ne_bytes ()); + } +Ok (obj) } }drivers/gpu/nova-core/gsp/cmdq.rs +1
-1@@ -202,7 +202,20 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); +
drivers/gpu/nova-core/gsp/cmdq.rs fn new(dev: &device::Device<device::Bound>) -> Result<Self> { · line 215
Quoted 10 lines
drivers/gpu/nova-core/gsp/cmdq.rs +10
-0+const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); + +let start = gsp_mem.dma_handle (); +// One by one GSP Page write to the memory to avoid stack overflow when allocating +// the whole array at once. +for iin 0 ..NUM_PTES { +dma_write! ( + gsp_mem, + [0 ]?.ptes.0 [i], +PteArray ::<NUM_PTES >::entry (start, i)?
Does ::<NUM_PTES> need to be mentioned here, or is the compiler able to infer it?
In any case, the updated patch
Thanks!
Gary Guo
reviewerRe: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
Quoted 88 lines · Alexandre Courbot
Quoted 87 lines · On Tue Mar 10, 2026 at 1:34 AM JST, Tim Kovalenko via B4 Relay wrote:
From: Tim Kovalenko <[email protected]>
The
Cmdq::newfunction was allocating aPteArraystruct on the stack and was causing a stack overflow with 8216 bytes.Modify the
PteArrayto calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.Signed-off-by Tim Kovalenko <[email protected]>--- drivers/gpu/nova-core/gsp.rs | 34 +++++++++++++++++++--------------- drivers/gpu/nova-core/gsp/cmdq.rs | 15 ++++++++++++++- 2 files changed, 33 insertions(+), 16 deletions(-)drivers/gpu/nova-core/gsp.rs +19
-15@@ -47,16 +47,11 @@unsafe impl <const NUM_ENTRIES :usize >AsBytes for PteArray <NUM_ENTRIES > {}impl <const NUM_PAGES :usize >PteArray <NUM_PAGES > { -/// Creates a new page table array mapping `NUM_PAGES` GSP pages starting at address `start`. -fn new (start:DmaAddress ) ->Result <Self > { -let mut ptes = [0u64 ;NUM_PAGES ]; -for (i, pte)in ptes.iter_mut ().enumerate () { - *pte = start - .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) - .ok_or (EOVERFLOW )?; - } - -Ok (Self (ptes)) +/// Returns the page table entry for `index`, for a mapping starting at `start` DmaAddress. +fn entry (start:DmaAddress , index:usize ) ->Result <u64 > { + start + .checked_add (num::usize_as_u64 (index) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW ) } }@@ -86,16 +81,25 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { NUM_PAGES * GSP_PAGE_SIZE, GFP_KERNEL | __GFP_ZERO, )?); -let ptes =PteArray ::<NUM_PAGES >::new (obj.0 .dma_handle ())?; + +let start_addr = obj.0 .dma_handle ();// SAFETY: `obj` has just been created and we are its sole user. -unsafe { -// Copy the self-mapping PTE at the expected location. +let pte_region =unsafe { obj.0 - .as_slice_mut (size_of ::<u64 >(),size_of_val (&ptes))? - .copy_from_slice (ptes.as_bytes ()) + .as_slice_mut (size_of ::<u64 >(),NUM_PAGES *size_of ::<u64 >())? }; +// This is a one by one GSP Page write to the memory +// to avoid stack overflow when allocating the whole array at once. +for (i, chunk)in pte_region.chunks_exact_mut (size_of ::<u64 >()).enumerate () { +let pte_value = start_addr + .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW )?; + + chunk.copy_from_slice (&pte_value.to_ne_bytes ()); + } +Ok (obj) } }drivers/gpu/nova-core/gsp/cmdq.rs +6
-1@@ -202,7 +202,20 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); + +const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); + +let start = gsp_mem.dma_handle (); +// One by one GSP Page write to the memory to avoid stack overflow when allocating +// the whole array at once.
Quoted 8 lines
drivers/gpu/nova-core/gsp/cmdq.rs fn new(dev: &device::Device<device::Bound>) -> Result<Self> { · line 215
Quoted 5 lines
drivers/gpu/nova-core/gsp/cmdq.rs +5
-0+for iin 0 ..NUM_PTES { +dma_write! ( + gsp_mem, + [0 ]?.ptes.0 [i], +PteArray ::<NUM_PTES >::entry (start, i)?Does
::<NUM_PTES>need to be mentioned here, or is the compiler able to infer it?
The function signature doesn't mention NUM_PTES at all, so no. In fact, perhaps the entry shouldn't be an associated method at all (even if is, it probably should be of PteArray::<0> or something.
Best,
Gary
Quoted 6 lines
In any case, the updated patch
Thanks!
Alexandre Courbot
maintainerRe: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
Quoted 98 lines · Gary Guo
Quoted 88 lines · Alexandre Courbot
Quoted 87 lines · On Tue Mar 10, 2026 at 1:34 AM JST, Tim Kovalenko via B4 Relay wrote:
From: Tim Kovalenko <[email protected]>
The
Cmdq::newfunction was allocating aPteArraystruct on the stack and was causing a stack overflow with 8216 bytes.Modify the
PteArrayto calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.Signed-off-by Tim Kovalenko <[email protected]>--- drivers/gpu/nova-core/gsp.rs | 34 +++++++++++++++++++--------------- drivers/gpu/nova-core/gsp/cmdq.rs | 15 ++++++++++++++- 2 files changed, 33 insertions(+), 16 deletions(-)drivers/gpu/nova-core/gsp.rs +19
-15@@ -47,16 +47,11 @@unsafe impl <const NUM_ENTRIES :usize >AsBytes for PteArray <NUM_ENTRIES > {}impl <const NUM_PAGES :usize >PteArray <NUM_PAGES > { -/// Creates a new page table array mapping `NUM_PAGES` GSP pages starting at address `start`. -fn new (start:DmaAddress ) ->Result <Self > { -let mut ptes = [0u64 ;NUM_PAGES ]; -for (i, pte)in ptes.iter_mut ().enumerate () { - *pte = start - .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) - .ok_or (EOVERFLOW )?; - } - -Ok (Self (ptes)) +/// Returns the page table entry for `index`, for a mapping starting at `start` DmaAddress. +fn entry (start:DmaAddress , index:usize ) ->Result <u64 > { + start + .checked_add (num::usize_as_u64 (index) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW ) } }@@ -86,16 +81,25 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { NUM_PAGES * GSP_PAGE_SIZE, GFP_KERNEL | __GFP_ZERO, )?); -let ptes =PteArray ::<NUM_PAGES >::new (obj.0 .dma_handle ())?; + +let start_addr = obj.0 .dma_handle ();// SAFETY: `obj` has just been created and we are its sole user. -unsafe { -// Copy the self-mapping PTE at the expected location. +let pte_region =unsafe { obj.0 - .as_slice_mut (size_of ::<u64 >(),size_of_val (&ptes))? - .copy_from_slice (ptes.as_bytes ()) + .as_slice_mut (size_of ::<u64 >(),NUM_PAGES *size_of ::<u64 >())? }; +// This is a one by one GSP Page write to the memory +// to avoid stack overflow when allocating the whole array at once. +for (i, chunk)in pte_region.chunks_exact_mut (size_of ::<u64 >()).enumerate () { +let pte_value = start_addr + .checked_add (num::usize_as_u64 (i) <<GSP_PAGE_SHIFT ) + .ok_or (EOVERFLOW )?; + + chunk.copy_from_slice (&pte_value.to_ne_bytes ()); + } +Ok (obj) } }drivers/gpu/nova-core/gsp/cmdq.rs +6
-1@@ -202,7 +202,20 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); + +const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); + +let start = gsp_mem.dma_handle (); +// One by one GSP Page write to the memory to avoid stack overflow when allocating +// the whole array at once. Quoted 8 lines
drivers/gpu/nova-core/gsp/cmdq.rs fn new(dev: &device::Device<device::Bound>) -> Result<Self> { · line 215
Quoted 5 lines
drivers/gpu/nova-core/gsp/cmdq.rs +5
-0+for iin 0 ..NUM_PTES { +dma_write! ( + gsp_mem, + [0 ]?.ptes.0 [i], +PteArray ::<NUM_PTES >::entry (start, i)?Does
::<NUM_PTES>need to be mentioned here, or is the compiler able to infer it?
Quoted 3 lines
The function signature doesn't mention
NUM_PTESat all, so no. In fact, perhaps theentryshouldn't be an associated method at all (even if is, it probably should be ofPteArray::<0>or something.
I had that thought as well - this calls for a redesign of the PteArray business - but also didn't want to interfere too much as this fix is very much (and quickly) needed. We will probably re-write this once we have access to the new I/O code anyway.
Danilo Krummrich
maintainerRe: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
Quoted 27 lines · Alexandre Courbot
Quoted 26 lines · Gary Guo
Quoted 24 lines · Alexandre Courbot
Quoted 10 lines · On Tue Mar 10, 2026 at 1:34 AM JST, Tim Kovalenko via B4 Relay wrote:
drivers/gpu/nova-core/gsp/cmdq.rs +1
-1@@ -202,7 +202,20 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> {let gsp_mem =CoherentAllocation ::<GspMem >::alloc_coherent (dev,1 ,GFP_KERNEL | __GFP_ZERO)?; -dma_write! (gsp_mem, [0 ]?.ptes,PteArray ::new (gsp_mem.dma_handle ())?); +drivers/gpu/nova-core/gsp/cmdq.rs fn new(dev: &device::Device<device::Bound>) -> Result<Self> { · line 215
Quoted 10 lines
drivers/gpu/nova-core/gsp/cmdq.rs +10
-0+const NUM_PTES :usize =GSP_PAGE_SIZE /size_of ::<u64 >(); + +let start = gsp_mem.dma_handle (); +// One by one GSP Page write to the memory to avoid stack overflow when allocating +// the whole array at once. +for iin 0 ..NUM_PTES { +dma_write! ( + gsp_mem, + [0 ]?.ptes.0 [i], +PteArray ::<NUM_PTES >::entry (start, i)?Does
::<NUM_PTES>need to be mentioned here, or is the compiler able to infer it?
Quoted 3 lines
Quoted 3 lines
The function signature doesn't mention
NUM_PTESat all, so no. In fact, perhaps theentryshouldn't be an associated method at all (even if is, it probably should be ofPteArray::<0>or something.
I think <0> is probably the best choice for this fix for now.
Quoted 4 lines
I had that thought as well - this calls for a redesign of the
PteArraybusiness - but also didn't want to interfere too much as this fix is very much (and quickly) needed. We will probably re-write this once we have access to the new I/O code anyway.
Not sure it actually needs a redesign, as I think this just goes away with I/O projections. That's also why I would add the following TODO comment on entry().
// TODO: Replace with `IoView` projections once available.
I.e. it is just a workaround for now.
Re: [PATCH v4 4/4] gpu: nova-core: fix stack overflow in GSP memory allocation
In reply to Tim KovalenkoQuoted 10 lines · On Mon Mar 9, 2026 at 5:34 PM CET, Tim Kovalenko via B4 Relay wrote:
From: Tim Kovalenko <[email protected]>
The
Cmdq::newfunction was allocating aPteArraystruct on the stack and was causing a stack overflow with 8216 bytes.Modify the
PteArrayto calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.Signed-off-by Tim Kovalenko <[email protected]>
Applied to drm-rust-fixes, thanks!
--- commit ---
commit c7940c8bf215b9dc6211781c77ce80e76982a723
Author: Tim Kovalenko <[email protected]> Date: Mon Mar 9 12:34:21 2026 -0400
gpu: nova-core: fix stack overflow in GSP memory allocation
The Cmdq::new function was allocating a PteArray struct on the stack and was causing a stack overflow with 8216 bytes.
Modify the PteArray to calculate and write the Page Table Entries directly into the coherent DMA buffer one-by-one. This reduces the stack usage quite a lot.
[ * Use PteArray::entry() in LogBuffer::new(),
* Add TODO comment to use IoView projections once available,
* Add PTE_ARRAY_SIZE constant to avoid duplication.
- Danilo ]
Danilo Krummrich
maintainerQuoted 4 lines · On Mon Mar 9, 2026 at 5:34 PM CET, Tim Kovalenko via B4 Relay wrote:
---
Changes in v4:
- Rebase on top of projection changes
Thanks for the quick follow-up!
There was no need to include the series you rebased onto, i.e. it is usually enough to just mention that your patch is based on another series and provide a link.
But don't worry, I just mention this for the next time, there is nothing that needs to be done on your end.
(One additional thing to note, in case you will actually have to (re-)send patches of other people in the future, is that such patches still need to have your Signed-off-by: in addition, since by sending them you are involved in the handling of those patches.)
Thanks,
Danilo