gpu: nova-core: gsp: add continuation record support
Subsystems (4)
v4 cover gpu: nova-core: gsp: add continuation record support
GSP commands over 16 pages need to be sent using "continuation records" which essentially means splitting the payload over multiple commands.
This series adds a command type ContinuationRecord which just writes its header and whatever payload it is given. It also adds types SplitState and SplitCommand which support splitting a large RPC into smaller ones while transparently letting regular sized RPCs be sent without extra copies.
The send pathway uses SplitState to send all commands, but if the command fits into 16 pages, it still writes directly into the command queue. If it is larger than 16 pages and needs continuation records, it writes into a staging buffer, so there is one copy.
---
Changes in v4:
- Removed Tested-by Zhi on the ContinuationRecord patch, since it
changed substantively.
- Incorporated Alex's design for SplitState
- Moved the continuation record types into their own module.
- Tightened visibility on continuation record types.
- Used non-zero sized command in tests.
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Rebased onto drm-rust-next
- Added some doc comments
- Reworded command_size doc comment
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Added doccoments
- Renamed driver_bytes_available_to_write to driver_write_area_size
- allocate_command_with_timeout merged allocate_command with timeout parameter
- Replaced hardcoded GSP_PAGE_SIZE * 16 with bindings
- Changed oversized command error from EIO to EMSGSIZE
- Added EMSGSIZE to kernel/error.rs
- Split WrappingCommand functionality into SplitState + SplitCommand enum
- Made max_size a const (MAX_CMD_SIZE)
- Removed send_continuation_record + added comment for type inference
- send_single_command now consumes the command
- Extracted command_size + used in SplitState
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Eliot Courtney (9):
gpu: nova-core: gsp: sort MsgFunction variants alphabetically
gpu: nova-core: gsp: add mechanism to wait for space on command queue
rust: add EMSGSIZE error code
gpu: nova-core: gsp: add checking oversized commands
gpu: nova-core: gsp: clarify invariant on command queue
gpu: nova-core: gsp: unconditionally call variable payload handling
gpu: nova-core: gsp: add command_size helper
gpu: nova-core: gsp: support large RPCs via continuation record
gpu: nova-core: gsp: add tests for continuation records
drivers/gpu/nova-core/gsp.rs | 1 + drivers/gpu/nova-core/gsp/cmdq.rs | 114 ++++++-- drivers/gpu/nova-core/gsp/continuation.rs | 305 ++++++++++++++++++++++ drivers/gpu/nova-core/gsp/fw.rs | 75 +++--- drivers/gpu/nova-core/gsp/fw/r570_144/bindings.rs | 1 + rust/kernel/error.rs | 1 + 6 files changed, 440 insertions(+), 57 deletions(-)
---
base-commit: 4a49fe23e357b48845e31fe9c28a802c05458198
change-id: 20260203-cmdq-continuation-b99f3d5966c3
Best regards,
Signature · 1 line
Eliot Courtney <[email protected]>
PATCH v4 1/9 gpu: nova-core: gsp: sort MsgFunction variants alphabetically
There is no particular order required here and keeping them alphabetical will help preventing future mistakes.
--- drivers/gpu/nova-core/gsp/fw.rs | 67 +++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 32 deletions(-)
drivers/gpu/nova-core/gsp/fw.rs +35 -32
@@ -191,34 +191,34 @@ pub(crate) fn new(gsp_firmware: &GspFirmware, fb_layout: &FbLayout) -> Self {#[repr( u32 )] pub (crate )enum MsgFunction {// Common function codes -Nop = bindings::NV_VGPU_MSG_FUNCTION_NOP , -SetGuestSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO , -AllocRoot = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT , +AllocChannelDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA , +AllocCtxDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA ,AllocDevice = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_DEVICE ,AllocMemory = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_MEMORY , -AllocCtxDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA , -AllocChannelDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA , -MapMemory = bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY , -BindCtxDma = bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA ,AllocObject = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT , +AllocRoot = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT , +BindCtxDma = bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA ,Free = bindings::NV_VGPU_MSG_FUNCTION_FREE , -Log = bindings::NV_VGPU_MSG_FUNCTION_LOG ,GetGspStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO , -SetRegistry = bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY , -GspSetSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO , +GetStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO ,GspInitPostObjGpu = bindings::NV_VGPU_MSG_FUNCTION_GSP_INIT_POST_OBJGPU ,GspRmControl = bindings::NV_VGPU_MSG_FUNCTION_GSP_RM_CONTROL , -GetStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO , +GspSetSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO , +Log = bindings::NV_VGPU_MSG_FUNCTION_LOG , +MapMemory = bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY , +Nop = bindings::NV_VGPU_MSG_FUNCTION_NOP , +SetGuestSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO , +SetRegistry = bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY ,// Event codes GspInitDone = bindings::NV_VGPU_MSG_EVENT_GSP_INIT_DONE , +GspLockdownNotice = bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE , +GspPostNoCat = bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD ,GspRunCpuSequencer = bindings::NV_VGPU_MSG_EVENT_GSP_RUN_CPU_SEQUENCER , -PostEvent = bindings::NV_VGPU_MSG_EVENT_POST_EVENT , -RcTriggered = bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED ,MmuFaultQueued = bindings::NV_VGPU_MSG_EVENT_MMU_FAULT_QUEUED ,OsErrorLog = bindings::NV_VGPU_MSG_EVENT_OS_ERROR_LOG , -GspPostNoCat = bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD , -GspLockdownNotice = bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE , +PostEvent = bindings::NV_VGPU_MSG_EVENT_POST_EVENT , +RcTriggered = bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED ,UcodeLibOsPrint = bindings::NV_VGPU_MSG_EVENT_UCODE_LIBOS_PRINT , }
@@ -227,38 +227,41 @@ impl TryFrom<u32> for MsgFunction {fn try_from (value:u32 ) ->Result <MsgFunction > {match value { - bindings::NV_VGPU_MSG_FUNCTION_NOP =>Ok (MsgFunction ::Nop ), - bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO => { -Ok (MsgFunction ::SetGuestSystemInfo ) - } - bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT =>Ok (MsgFunction ::AllocRoot ), +// Common function codes + bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA =>Ok (MsgFunction ::AllocChannelDma ), + bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA =>Ok (MsgFunction ::AllocCtxDma ), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_DEVICE =>Ok (MsgFunction ::AllocDevice ), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_MEMORY =>Ok (MsgFunction ::AllocMemory ), - bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA =>Ok (MsgFunction ::AllocCtxDma ), - bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA =>Ok (MsgFunction ::AllocChannelDma ), - bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY =>Ok (MsgFunction ::MapMemory ), - bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA =>Ok (MsgFunction ::BindCtxDma ), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT =>Ok (MsgFunction ::AllocObject ), + bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT =>Ok (MsgFunction ::AllocRoot ), + bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA =>Ok (MsgFunction ::BindCtxDma ), bindings::NV_VGPU_MSG_FUNCTION_FREE =>Ok (MsgFunction ::Free ), - bindings::NV_VGPU_MSG_FUNCTION_LOG =>Ok (MsgFunction ::Log ), bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO =>Ok (MsgFunction ::GetGspStaticInfo ), - bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY =>Ok (MsgFunction ::SetRegistry ), - bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO =>Ok (MsgFunction ::GspSetSystemInfo ), + bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO =>Ok (MsgFunction ::GetStaticInfo ), bindings::NV_VGPU_MSG_FUNCTION_GSP_INIT_POST_OBJGPU => {Ok (MsgFunction ::GspInitPostObjGpu ) } bindings::NV_VGPU_MSG_FUNCTION_GSP_RM_CONTROL =>Ok (MsgFunction ::GspRmControl ), - bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO =>Ok (MsgFunction ::GetStaticInfo ), + bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO =>Ok (MsgFunction ::GspSetSystemInfo ), + bindings::NV_VGPU_MSG_FUNCTION_LOG =>Ok (MsgFunction ::Log ), + bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY =>Ok (MsgFunction ::MapMemory ), + bindings::NV_VGPU_MSG_FUNCTION_NOP =>Ok (MsgFunction ::Nop ), + bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO => { +Ok (MsgFunction ::SetGuestSystemInfo ) + } + bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY =>Ok (MsgFunction ::SetRegistry ), + +// Event codes bindings::NV_VGPU_MSG_EVENT_GSP_INIT_DONE =>Ok (MsgFunction ::GspInitDone ), + bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE =>Ok (MsgFunction ::GspLockdownNotice ), + bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD =>Ok (MsgFunction ::GspPostNoCat ), bindings::NV_VGPU_MSG_EVENT_GSP_RUN_CPU_SEQUENCER => {Ok (MsgFunction ::GspRunCpuSequencer ) } - bindings::NV_VGPU_MSG_EVENT_POST_EVENT =>Ok (MsgFunction ::PostEvent ), - bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED =>Ok (MsgFunction ::RcTriggered ), bindings::NV_VGPU_MSG_EVENT_MMU_FAULT_QUEUED =>Ok (MsgFunction ::MmuFaultQueued ), bindings::NV_VGPU_MSG_EVENT_OS_ERROR_LOG =>Ok (MsgFunction ::OsErrorLog ), - bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD =>Ok (MsgFunction ::GspPostNoCat ), - bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE =>Ok (MsgFunction ::GspLockdownNotice ), + bindings::NV_VGPU_MSG_EVENT_POST_EVENT =>Ok (MsgFunction ::PostEvent ), + bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED =>Ok (MsgFunction ::RcTriggered ), bindings::NV_VGPU_MSG_EVENT_UCODE_LIBOS_PRINT =>Ok (MsgFunction ::UcodeLibOsPrint ), _ =>Err (EINVAL ), }
Signature · 1 line
2.53.0
Gary Guo
reviewerRe: [PATCH v4 1/9] gpu: nova-core: gsp: sort MsgFunction variants alphabetically
Quoted 2 lines · Eliot Courtney
There is no particular order required here and keeping them alphabetical will help preventing future mistakes.
Looks like the current order is in increasing opcode order. Granted, currently they're generated in bindings and then included as such, but perhaps eventually Rust code can be generated directly so the ordering could make sense?
Best,
Gary
Quoted 120 lines
Tested-by Zhi Wang <[email protected]>Signed-off-by Eliot Courtney <[email protected]>--- drivers/gpu/nova-core/gsp/fw.rs | 67 +++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 32 deletions(-)drivers/gpu/nova-core/gsp/fw.rs +35
-32@@ -191,34 +191,34 @@ pub(crate) fn new(gsp_firmware: &GspFirmware, fb_layout: &FbLayout) -> Self {#[repr( u32 )] pub (crate )enum MsgFunction {// Common function codes -Nop = bindings::NV_VGPU_MSG_FUNCTION_NOP , -SetGuestSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO , -AllocRoot = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT , +AllocChannelDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA , +AllocCtxDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA ,AllocDevice = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_DEVICE ,AllocMemory = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_MEMORY , -AllocCtxDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA , -AllocChannelDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA , -MapMemory = bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY , -BindCtxDma = bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA ,AllocObject = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT , +AllocRoot = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT , +BindCtxDma = bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA ,Free = bindings::NV_VGPU_MSG_FUNCTION_FREE , -Log = bindings::NV_VGPU_MSG_FUNCTION_LOG ,GetGspStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO , -SetRegistry = bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY , -GspSetSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO , +GetStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO ,GspInitPostObjGpu = bindings::NV_VGPU_MSG_FUNCTION_GSP_INIT_POST_OBJGPU ,GspRmControl = bindings::NV_VGPU_MSG_FUNCTION_GSP_RM_CONTROL , -GetStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO , +GspSetSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO , +Log = bindings::NV_VGPU_MSG_FUNCTION_LOG , +MapMemory = bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY , +Nop = bindings::NV_VGPU_MSG_FUNCTION_NOP , +SetGuestSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO , +SetRegistry = bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY ,// Event codes GspInitDone = bindings::NV_VGPU_MSG_EVENT_GSP_INIT_DONE , +GspLockdownNotice = bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE , +GspPostNoCat = bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD ,GspRunCpuSequencer = bindings::NV_VGPU_MSG_EVENT_GSP_RUN_CPU_SEQUENCER , -PostEvent = bindings::NV_VGPU_MSG_EVENT_POST_EVENT , -RcTriggered = bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED ,MmuFaultQueued = bindings::NV_VGPU_MSG_EVENT_MMU_FAULT_QUEUED ,OsErrorLog = bindings::NV_VGPU_MSG_EVENT_OS_ERROR_LOG , -GspPostNoCat = bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD , -GspLockdownNotice = bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE , +PostEvent = bindings::NV_VGPU_MSG_EVENT_POST_EVENT , +RcTriggered = bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED ,UcodeLibOsPrint = bindings::NV_VGPU_MSG_EVENT_UCODE_LIBOS_PRINT , }@@ -227,38 +227,41 @@ impl TryFrom<u32> for MsgFunction {fn try_from (value:u32 ) ->Result <MsgFunction > {match value { - bindings::NV_VGPU_MSG_FUNCTION_NOP =>Ok (MsgFunction ::Nop ), - bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO => { -Ok (MsgFunction ::SetGuestSystemInfo ) - } - bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT =>Ok (MsgFunction ::AllocRoot ), +// Common function codes + bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA =>Ok (MsgFunction ::AllocChannelDma ), + bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA =>Ok (MsgFunction ::AllocCtxDma ), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_DEVICE =>Ok (MsgFunction ::AllocDevice ), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_MEMORY =>Ok (MsgFunction ::AllocMemory ), - bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA =>Ok (MsgFunction ::AllocCtxDma ), - bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA =>Ok (MsgFunction ::AllocChannelDma ), - bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY =>Ok (MsgFunction ::MapMemory ), - bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA =>Ok (MsgFunction ::BindCtxDma ), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT =>Ok (MsgFunction ::AllocObject ), + bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT =>Ok (MsgFunction ::AllocRoot ), + bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA =>Ok (MsgFunction ::BindCtxDma ), bindings::NV_VGPU_MSG_FUNCTION_FREE =>Ok (MsgFunction ::Free ), - bindings::NV_VGPU_MSG_FUNCTION_LOG =>Ok (MsgFunction ::Log ), bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO =>Ok (MsgFunction ::GetGspStaticInfo ), - bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY =>Ok (MsgFunction ::SetRegistry ), - bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO =>Ok (MsgFunction ::GspSetSystemInfo ), + bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO =>Ok (MsgFunction ::GetStaticInfo ), bindings::NV_VGPU_MSG_FUNCTION_GSP_INIT_POST_OBJGPU => {Ok (MsgFunction ::GspInitPostObjGpu ) } bindings::NV_VGPU_MSG_FUNCTION_GSP_RM_CONTROL =>Ok (MsgFunction ::GspRmControl ), - bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO =>Ok (MsgFunction ::GetStaticInfo ), + bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO =>Ok (MsgFunction ::GspSetSystemInfo ), + bindings::NV_VGPU_MSG_FUNCTION_LOG =>Ok (MsgFunction ::Log ), + bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY =>Ok (MsgFunction ::MapMemory ), + bindings::NV_VGPU_MSG_FUNCTION_NOP =>Ok (MsgFunction ::Nop ), + bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO => { +Ok (MsgFunction ::SetGuestSystemInfo ) + } + bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY =>Ok (MsgFunction ::SetRegistry ), + +// Event codes bindings::NV_VGPU_MSG_EVENT_GSP_INIT_DONE =>Ok (MsgFunction ::GspInitDone ), + bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE =>Ok (MsgFunction ::GspLockdownNotice ), + bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD =>Ok (MsgFunction ::GspPostNoCat ), bindings::NV_VGPU_MSG_EVENT_GSP_RUN_CPU_SEQUENCER => {Ok (MsgFunction ::GspRunCpuSequencer ) } - bindings::NV_VGPU_MSG_EVENT_POST_EVENT =>Ok (MsgFunction ::PostEvent ), - bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED =>Ok (MsgFunction ::RcTriggered ), bindings::NV_VGPU_MSG_EVENT_MMU_FAULT_QUEUED =>Ok (MsgFunction ::MmuFaultQueued ), bindings::NV_VGPU_MSG_EVENT_OS_ERROR_LOG =>Ok (MsgFunction ::OsErrorLog ), - bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD =>Ok (MsgFunction ::GspPostNoCat ), - bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE =>Ok (MsgFunction ::GspLockdownNotice ), + bindings::NV_VGPU_MSG_EVENT_POST_EVENT =>Ok (MsgFunction ::PostEvent ), + bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED =>Ok (MsgFunction ::RcTriggered ), bindings::NV_VGPU_MSG_EVENT_UCODE_LIBOS_PRINT =>Ok (MsgFunction ::UcodeLibOsPrint ), _ =>Err (EINVAL ), }
Alexandre Courbot
maintainerRe: [PATCH v4 1/9] gpu: nova-core: gsp: sort MsgFunction variants alphabetically
Quoted 7 lines · Gary Guo
Quoted 2 lines · Eliot Courtney
There is no particular order required here and keeping them alphabetical will help preventing future mistakes.
Looks like the current order is in increasing opcode order. Granted, currently they're generated in bindings and then included as such, but perhaps eventually Rust code can be generated directly so the ordering could make sense?
Yes, there are plans to get more code generated and that would include this as well.
For now alphabetical order makes sense to me as the opcodes come from the bindings and have no guarantee of being stable.
PATCH v4 2/9 gpu: nova-core: gsp: add mechanism to wait for space on command queue
In reply to Eliot CourtneyAdd a timeout to allocate_command which waits for space on the GSP command queue. It uses a similar timeout to nouveau.
This lets send_command wait for space to free up in the command queue. This is required to support continuation records which can fill up the queue.
--- drivers/gpu/nova-core/gsp/cmdq.rs | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-)
drivers/gpu/nova-core/gsp/cmdq.rs +27 -12
@@ -250,6 +250,19 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { } } +/// Returns the size of the region of the CPU message queue that the driver is currently allowed +/// to write to, in bytes. +fn driver_write_area_size (&self) ->usize { +let tx = self.cpu_write_ptr (); +let rx = self.gsp_read_ptr (); + +// `rx` and `tx` are both in `0..MSGQ_NUM_PAGES` per the invariants of `gsp_read_ptr` and +// `cpu_write_ptr`. The minimum value case is where `rx == 0` and `tx == MSGQ_NUM_PAGES - +// 1`, which gives `0 + MSGQ_NUM_PAGES - (MSGQ_NUM_PAGES - 1) - 1 == 0`. +let slots = (rx +MSGQ_NUM_PAGES - tx -1 ) %MSGQ_NUM_PAGES ; + num::u32_as_usize (slots) *GSP_PAGE_SIZE + } +/// Returns the region of the GSP message queue that the driver is currently allowed to read /// from. ///
@@ -281,15 +294,22 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { }/// Allocates a region on the command queue that is large enough to send a command of `size` -/// bytes. +/// bytes, waiting for space to become available based on the provided timeout. /// /// This returns a [`GspCommand`] ready to be written to by the caller. /// /// # Errors /// -/// - `EAGAIN` if the driver area is too small to hold the requested command. +/// - `ETIMEDOUT` if space does not become available within the timeout. /// - `EIO` if the command header is not properly aligned. -fn allocate_command (&mut self, size:usize ) ->Result <GspCommand <'_>> { +fn allocate_command (&mut self, size:usize , timeout:Delta ) ->Result <GspCommand <'_>> { +read_poll_timeout ( + ||Ok (self.driver_write_area_size ()), + |available_bytes| *available_bytes >=size_of ::<GspMsgElement >() + size, +Delta ::ZERO , + timeout, + )?; +// Get the current writable area as an array of bytes. let (slice_1, slice_2) = {let (slice_1, slice_2) = self.driver_write_area ();
@@ -298,13 +318,6 @@ fn allocate_command(&mut self, size: usize) -> Result<GspCommand<'_>> { (slice_1.as_flattened_mut (), slice_2.as_flattened_mut ()) }; -// If the GSP is still processing previous messages the shared region -// may be full in which case we will have to retry once the GSP has -// processed the existing commands. -if size_of ::<GspMsgElement >() + size > slice_1.len () + slice_2.len () { -return Err (EAGAIN ); - } -// Extract area for the `GspMsgElement`. let (header, slice_1) =GspMsgElement ::from_bytes_mut_prefix (slice_1).ok_or (EIO )?;
@@ -497,7 +510,7 @@ fn notify_gsp(bar: &Bar0) {/// /// # Errors /// -/// - `EAGAIN` if there was not enough space in the command queue to send the command. +/// - `ETIMEDOUT` if space does not become available within the timeout. /// - `EIO` if the variable payload requested by the command has not been entirely /// written to by its [`CommandToGsp::init_variable_payload`] method. ///
@@ -509,7 +522,9 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result Error: From<M::InitError>, {let command_size =size_of ::<M ::Command >() + command.variable_payload_len (); -let dst = self.gsp_mem.allocate_command (command_size)?; +let dst = self + .gsp_mem + .allocate_command (command_size,Delta ::from_secs (1 ))?;// Extract area for the command itself. let (cmd, payload_1) =M ::Command ::from_bytes_mut_prefix (dst.contents.0 ).ok_or (EIO )?;
Signature · 1 line
2.53.0
Gary Guo
reviewerRe: [PATCH v4 2/9] gpu: nova-core: gsp: add mechanism to wait for space on command queue
Quoted 6 lines · Eliot Courtney
Add a timeout to
allocate_commandwhich waits for space on the GSP command queue. It uses a similar timeout to nouveau.This lets
send_commandwait for space to free up in the command queue. This is required to support continuation records which can fill up the queue.
Any reason that this isn't implemented as a poll_allocate_command which just returns a EAGAIN, and then a wrapper function that just waits for space to be ready when it got one? This way the logic is cleaner.
(I write this with Rust async in mind)
Quoted 81 lines
Tested-by Zhi Wang <[email protected]>Signed-off-by Eliot Courtney <[email protected]>--- drivers/gpu/nova-core/gsp/cmdq.rs | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-)drivers/gpu/nova-core/gsp/cmdq.rs +24
-11@@ -250,6 +250,19 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { } } +/// Returns the size of the region of the CPU message queue that the driver is currently allowed +/// to write to, in bytes. +fn driver_write_area_size (&self) ->usize { +let tx = self.cpu_write_ptr (); +let rx = self.gsp_read_ptr (); + +// `rx` and `tx` are both in `0..MSGQ_NUM_PAGES` per the invariants of `gsp_read_ptr` and +// `cpu_write_ptr`. The minimum value case is where `rx == 0` and `tx == MSGQ_NUM_PAGES - +// 1`, which gives `0 + MSGQ_NUM_PAGES - (MSGQ_NUM_PAGES - 1) - 1 == 0`. +let slots = (rx +MSGQ_NUM_PAGES - tx -1 ) %MSGQ_NUM_PAGES ; + num::u32_as_usize (slots) *GSP_PAGE_SIZE + } +/// Returns the region of the GSP message queue that the driver is currently allowed to read /// from. /// @@ -281,15 +294,22 @@ fn new(dev: &device::Device<device::Bound>) -> Result<Self> { }/// Allocates a region on the command queue that is large enough to send a command of `size` -/// bytes. +/// bytes, waiting for space to become available based on the provided timeout. /// /// This returns a [`GspCommand`] ready to be written to by the caller. /// /// # Errors /// -/// - `EAGAIN` if the driver area is too small to hold the requested command. +/// - `ETIMEDOUT` if space does not become available within the timeout. /// - `EIO` if the command header is not properly aligned. -fn allocate_command (&mut self, size:usize ) ->Result <GspCommand <'_>> { +fn allocate_command (&mut self, size:usize , timeout:Delta ) ->Result <GspCommand <'_>> { +read_poll_timeout ( + ||Ok (self.driver_write_area_size ()), + |available_bytes| *available_bytes >=size_of ::<GspMsgElement >() + size, +Delta ::ZERO , + timeout, + )?; +// Get the current writable area as an array of bytes. let (slice_1, slice_2) = {let (slice_1, slice_2) = self.driver_write_area ();@@ -298,13 +318,6 @@ fn allocate_command(&mut self, size: usize) -> Result<GspCommand<'_>> { (slice_1.as_flattened_mut (), slice_2.as_flattened_mut ()) }; -// If the GSP is still processing previous messages the shared region -// may be full in which case we will have to retry once the GSP has -// processed the existing commands. -if size_of ::<GspMsgElement >() + size > slice_1.len () + slice_2.len () { -return Err (EAGAIN ); - } -// Extract area for the `GspMsgElement`. let (header, slice_1) =GspMsgElement ::from_bytes_mut_prefix (slice_1).ok_or (EIO )?;@@ -497,7 +510,7 @@ fn notify_gsp(bar: &Bar0) {/// /// # Errors /// -/// - `EAGAIN` if there was not enough space in the command queue to send the command. +/// - `ETIMEDOUT` if space does not become available within the timeout. /// - `EIO` if the variable payload requested by the command has not been entirely /// written to by its [`CommandToGsp::init_variable_payload`] method. ///
drivers/gpu/nova-core/gsp/cmdq.rs pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result · line 527
Quoted 7 lines
drivers/gpu/nova-core/gsp/cmdq.rs +3
-1@@ -509,7 +522,9 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result Error: From<M::InitError>, {let command_size =size_of ::<M ::Command >() + command.variable_payload_len (); -let dst = self.gsp_mem.allocate_command (command_size)?; +let dst = self + .gsp_mem + .allocate_command (command_size,Delta ::from_secs (1 ))?;
Let's make these consts, not magic numbers.
Best,
Gary
Quoted 3 lines
drivers/gpu/nova-core/gsp/cmdq.rs +0
-0// Extract area for the command itself. let (cmd, payload_1) =M ::Command ::from_bytes_mut_prefix (dst.contents.0 ).ok_or (EIO )?;
Re: [PATCH v4 2/9] gpu: nova-core: gsp: add mechanism to wait for space on command queue
Quoted 11 lines · Gary Guo
Quoted 6 lines · Eliot Courtney
Add a timeout to
allocate_commandwhich waits for space on the GSP command queue. It uses a similar timeout to nouveau.This lets
send_commandwait for space to free up in the command queue. This is required to support continuation records which can fill up the queue.Any reason that this isn't implemented as a
poll_allocate_commandwhich just returns aEAGAIN, and then a wrapper function that just waits for space to be ready when it got one? This way the logic is cleaner.
This kind of structure is what I originally did (see
https://lore.kernel.org/all/[email protected]/)
although it wasn't quite as nice since allocate_command takes &mut self and isn't callable from read_poll_timeout. Alex suggested merging these into one as it simplifies a few things. But maybe I am missing some better way to do it.
Alexandre Courbot
maintainerRe: [PATCH v4 2/9] gpu: nova-core: gsp: add mechanism to wait for space on command queue
Quoted 13 lines · Eliot Courtney
Quoted 11 lines · Gary Guo
Quoted 6 lines · Eliot Courtney
Add a timeout to
allocate_commandwhich waits for space on the GSP command queue. It uses a similar timeout to nouveau.This lets
send_commandwait for space to free up in the command queue. This is required to support continuation records which can fill up the queue.Any reason that this isn't implemented as a
poll_allocate_commandwhich just returns aEAGAIN, and then a wrapper function that just waits for space to be ready when it got one? This way the logic is cleaner.
Quoted 6 lines
This kind of structure is what I originally did (see
https://lore.kernel.org/all/[email protected]/)
although it wasn't quite as nice sinceallocate_commandtakes &mut self and isn't callable fromread_poll_timeout. Alex suggested merging these into one as it simplifies a few things. But maybe I am missing some better way to do it.
The rationale for this is that we don't have a case for polling for command queue availability - the GSP is expected to consume all the data sent to it rapidly, so we have a soft guarantee that the queue will be ready soon. We also don't have a case for doing something else until the queue is ready, AFAICT.
The current form is simpler code-wise, and if we ever need to break it into two poll and wait methods, we can do it trivially when the need arises.
PATCH v4 3/9 rust: add EMSGSIZE error code
In reply to Eliot CourtneyAdd the EMSGSIZE error code, which indicates that a message is too long.
--- rust/kernel/error.rs | 1 + 1 file changed, 1 insertion(+)
rust/kernel/error.rs +1 -0
@@ -67,6 +67,7 @@ macro_rules! declare_err {declare_err! (EDOM ,"Math argument out of domain of func." );declare_err! (ERANGE ,"Math result not representable." );declare_err! (EOVERFLOW ,"Value too large for defined data type." ); +declare_err! (EMSGSIZE ,"Message too long." );declare_err! (ETIMEDOUT ,"Connection timed out." );declare_err! (ERESTARTSYS ,"Restart the system call." );declare_err! (ERESTARTNOINTR ,"System call was interrupted by a signal and will be restarted." );
Signature · 1 line
2.53.0
Re: [PATCH v4 3/9] rust: add EMSGSIZE error code
Quoted 6 lines · Eliot Courtney
Add the EMSGSIZE error code, which indicates that a message is too long.
Tested-by Zhi Wang <[email protected]>Acked-by Miguel Ojeda <[email protected]>Signed-off-by Eliot Courtney <[email protected]>
Quoted 3 lines
--- rust/kernel/error.rs | 1 + 1 file changed, 1 insertion(+)
PATCH v4 4/9 gpu: nova-core: gsp: add checking oversized commands
In reply to Eliot CourtneyThe limit is 16 pages for a single command sent to the GSP. Return an error if allocate_command is called with a too large size.
--- drivers/gpu/nova-core/gsp/cmdq.rs | 7 ++++++- drivers/gpu/nova-core/gsp/fw.rs | 4 ++++ drivers/gpu/nova-core/gsp/fw/r570_144/bindings.rs | 1 + 3 files changed, 11 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/gsp/cmdq.rs +6 -1
@@ -32,7 +32,8 @@ GspMsgElement, MsgFunction, MsgqRxHeader, - MsgqTxHeader, // + MsgqTxHeader, + GSP_MSG_QUEUE_ELEMENT_SIZE_MAX, // }, PteArray, GSP_PAGE_SHIFT,
@@ -300,9 +301,13 @@ fn driver_write_area_size(&self) -> usize {/// /// # Errors /// +/// - `EMSGSIZE` if the command is larger than [`GSP_MSG_QUEUE_ELEMENT_SIZE_MAX`]. /// - `ETIMEDOUT` if space does not become available within the timeout. /// - `EIO` if the command header is not properly aligned. fn allocate_command (&mut self, size:usize , timeout:Delta ) ->Result <GspCommand <'_>> { +if size_of ::<GspMsgElement >() + size >GSP_MSG_QUEUE_ELEMENT_SIZE_MAX { +return Err (EMSGSIZE ); + }read_poll_timeout ( ||Ok (self.driver_write_area_size ()), |available_bytes| *available_bytes >= size_of::<GspMsgElement>() + size,
drivers/gpu/nova-core/gsp/fw.rs +4 -0
@@ -39,6 +39,10 @@ }, }; +/// Maximum size of a single GSP message queue element in bytes. +pub (crate )const GSP_MSG_QUEUE_ELEMENT_SIZE_MAX :usize = + num::u32_as_usize (bindings::GSP_MSG_QUEUE_ELEMENT_SIZE_MAX ); +/// Empty type to group methods related to heap parameters for running the GSP firmware. enum GspFwHeapParams {}
drivers/gpu/nova-core/gsp/fw/r570_144/bindings.rs +1 -0
@@ -43,6 +43,7 @@ fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {pub const GSP_FW_WPR_META_REVISION :u32 =1 ;pub const GSP_FW_WPR_META_MAGIC :i64 = -2577556379034558285 ;pub const REGISTRY_TABLE_ENTRY_TYPE_DWORD :u32 =1 ; +pub const GSP_MSG_QUEUE_ELEMENT_SIZE_MAX :u32 =65536 ;pub type __u8 = ffi::c_uchar ;pub type __u16 = ffi::c_ushort ;pub type __u32 = ffi::c_uint ;
Signature · 1 line
2.53.0
PATCH v4 5/9 gpu: nova-core: gsp: clarify invariant on command queue
In reply to Eliot CourtneyClarify why using only the first returned slice from allocate_command for the message headers is okay.
--- drivers/gpu/nova-core/gsp/cmdq.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/gsp/cmdq.rs +3 -1
@@ -531,7 +531,9 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result .gsp_mem .allocate_command (command_size,Delta ::from_secs (1 ))?; -// Extract area for the command itself. +// Extract area for the command itself. The GSP message header and the command header +// together are guaranteed to fit entirely into a single page, so it's ok to only look +// at `dst.contents.0` here. let (cmd, payload_1) =M ::Command ::from_bytes_mut_prefix (dst.contents.0 ).ok_or (EIO )?;// Fill the header and command in-place.
Signature · 1 line
2.53.0
PATCH v4 6/9 gpu: nova-core: gsp: unconditionally call variable payload handling
In reply to Eliot CourtneyUnconditionally call the variable length payload code, which is a no-op if there is no such payload but could defensively catch some coding errors by e.g. checking that the allocated size is completely filled.
--- drivers/gpu/nova-core/gsp/cmdq.rs | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
drivers/gpu/nova-core/gsp/cmdq.rs +6 -8
@@ -545,16 +545,14 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result command.init ().__init (core::ptr::from_mut (cmd))?; } -// Fill the variable-length payload. -if command_size >size_of ::<M ::Command >() { -let mut sbuffer = -SBufferIter ::new_writer ([&mut payload_1[..], &mut dst.contents.1 [..]]); - command.init_variable_payload (&mut sbuffer)?; +// Fill the variable-length payload, which may be empty. +let mut sbuffer =SBufferIter ::new_writer ([&mut payload_1[..], &mut dst.contents.1 [..]]); + command.init_variable_payload (&mut sbuffer)?; -if !sbuffer.is_empty () { -return Err (EIO ); - } +if !sbuffer.is_empty () { +return Err (EIO ); } +drop (sbuffer);// Compute checksum now that the whole message is ready. dst.header
Signature · 1 line
2.53.0
PATCH v4 7/9 gpu: nova-core: gsp: add command_size helper
In reply to Eliot CourtneyAdd a helper function which computes the size of a command.
--- drivers/gpu/nova-core/gsp/cmdq.rs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/gsp/cmdq.rs +10 -1
@@ -450,6 +450,15 @@ struct GspMessage<'a> { contents: (&'a [u8], &'a [u8]), } +/// Computes the total size of the command (including its variable-length payload) without the +/// [`GspMsgElement`] header. +fn command_size <M >(command: &M ) ->usize +where +M :CommandToGsp , +{ +size_of ::<M ::Command >() + command.variable_payload_len () +} +/// GSP command queue. /// /// Provides the ability to send commands and receive messages from the GSP using a shared memory
@@ -526,7 +535,7 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result// This allows all error types, including `Infallible`, to be used for `M::InitError`. Error: From<M::InitError>, { -let command_size =size_of ::<M ::Command >() + command.variable_payload_len (); +let command_size =command_size (&command);let dst = self .gsp_mem .allocate_command (command_size,Delta ::from_secs (1 ))?;
Signature · 1 line
2.53.0
Gary Guo
reviewerRe: [PATCH v4 7/9] gpu: nova-core: gsp: add command_size helper
Quoted 15 lines · Eliot Courtney
Add a helper function which computes the size of a command.
Tested-by Zhi Wang <[email protected]>Signed-off-by Eliot Courtney <[email protected]>--- drivers/gpu/nova-core/gsp/cmdq.rs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)drivers/gpu/nova-core/gsp/cmdq.rs +0
-0@@ -450,6 +450,15 @@ struct GspMessage<'a> { contents: (&'a [u8], &'a [u8]), }
drivers/gpu/nova-core/gsp/cmdq.rs struct GspMessage<'a> { · line 461
Quoted 10 lines
drivers/gpu/nova-core/gsp/cmdq.rs +9
-0+/// Computes the total size of the command (including its variable-length payload) without the +/// [`GspMsgElement`] header. +fn command_size <M >(command: &M ) ->usize +where +M :CommandToGsp , +{ +size_of ::<M ::Command >() + command.variable_payload_len () +} +
This could just a provided method on CommandToGsp?
Best,
Gary
Quoted 12 lines
drivers/gpu/nova-core/gsp/cmdq.rs +1
-1/// GSP command queue. /// /// Provides the ability to send commands and receive messages from the GSP using a shared memory @@ -526,7 +535,7 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result// This allows all error types, including `Infallible`, to be used for `M::InitError`. Error: From<M::InitError>, { -let command_size =size_of ::<M ::Command >() + command.variable_payload_len (); +let command_size =command_size (&command);let dst = self .gsp_mem .allocate_command (command_size,Delta ::from_secs (1 ))?;
Re: [PATCH v4 7/9] gpu: nova-core: gsp: add command_size helper
Quoted 17 lines · Gary Guo
Quoted 16 lines · Eliot Courtney
Add a helper function which computes the size of a command.
Tested-by Zhi Wang <[email protected]>Signed-off-by Eliot Courtney <[email protected]>--- drivers/gpu/nova-core/gsp/cmdq.rs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)drivers/gpu/nova-core/gsp/cmdq.rs +0
-0@@ -450,6 +450,15 @@ struct GspMessage<'a> { contents: (&'a [u8], &'a [u8]), }
Quoted 11 lines
drivers/gpu/nova-core/gsp/cmdq.rs struct GspMessage<'a> { · line 461
Quoted 9 lines
drivers/gpu/nova-core/gsp/cmdq.rs +9
-0+/// Computes the total size of the command (including its variable-length payload) without the +/// [`GspMsgElement`] header. +fn command_size <M >(command: &M ) ->usize +where +M :CommandToGsp , +{ +size_of ::<M ::Command >() + command.variable_payload_len () +} +This could just a provided method on
CommandToGsp?
I discussed this with Alex before[1] and my idea was that it's odd to add it as a default trait method since implementors could override it when they really shouldn't be able to, since it needs to agree with the size of the command and the variable payload length.
WDYT? Is there a clear convention of doing this over the kernel? It just feels odd to me although I agree it's useful. Would be perfect if there was an easy way to prevent it from being overridden.
PATCH v4 8/9 gpu: nova-core: gsp: support large RPCs via continuation record
In reply to Eliot CourtneySplits large RPCs if necessary and sends the remaining parts using continuation records. RPCs that do not need continuation records continue to write directly into the command buffer. Ones that do write into a staging buffer first, so there is one copy.
Continuation record for receive is not necessary to support at the moment because those replies do not need to be read and are currently drained by retrying receive_msg on ERANGE.
--- drivers/gpu/nova-core/gsp.rs | 1 + drivers/gpu/nova-core/gsp/cmdq.rs | 41 +++++++- drivers/gpu/nova-core/gsp/continuation.rs | 167 ++++++++++++++++++++++++++++++ drivers/gpu/nova-core/gsp/fw.rs | 4 + 4 files changed, 210 insertions(+), 3 deletions(-)
drivers/gpu/nova-core/gsp.rs +1 -0
@@ -16,6 +16,7 @@pub (crate )mod cmdq;pub (crate )mod commands; +mod continuation;mod fw;mod sequencer;
drivers/gpu/nova-core/gsp/cmdq.rs +38 -3
71 lines not on this page · raw message
drivers/gpu/nova-core/gsp/continuation.rs new file +167 -0
167 lines not on this page · raw message
drivers/gpu/nova-core/gsp/fw.rs +4 -0
@@ -202,6 +202,7 @@ pub(crate) enum MsgFunction { AllocObject = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT, AllocRoot = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT, BindCtxDma = bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA, + ContinuationRecord = bindings::NV_VGPU_MSG_FUNCTION_CONTINUATION_RECORD, Free = bindings::NV_VGPU_MSG_FUNCTION_FREE, GetGspStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO, GetStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO,
@@ -239,6 +240,9 @@ fn try_from(value: u32) -> Result<MsgFunction> { bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT => Ok(MsgFunction::AllocObject), bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT => Ok(MsgFunction::AllocRoot), bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA => Ok(MsgFunction::BindCtxDma), + bindings::NV_VGPU_MSG_FUNCTION_CONTINUATION_RECORD => { + Ok(MsgFunction::ContinuationRecord) + } bindings::NV_VGPU_MSG_FUNCTION_FREE => Ok(MsgFunction::Free), bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO => Ok(MsgFunction::GetGspStaticInfo), bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO => Ok(MsgFunction::GetStaticInfo),
Signature · 1 line
2.53.0
Alexandre Courbot
maintainerRe: [PATCH v4 8/9] gpu: nova-core: gsp: support large RPCs via continuation record
Quoted 22 lines · Eliot Courtney
Splits large RPCs if necessary and sends the remaining parts using continuation records. RPCs that do not need continuation records continue to write directly into the command buffer. Ones that do write into a staging buffer first, so there is one copy.
Continuation record for receive is not necessary to support at the moment because those replies do not need to be read and are currently drained by retrying
receive_msgon ERANGE.Signed-off-by Eliot Courtney <[email protected]>--- drivers/gpu/nova-core/gsp.rs | 1 + drivers/gpu/nova-core/gsp/cmdq.rs | 41 +++++++- drivers/gpu/nova-core/gsp/continuation.rs | 167 ++++++++++++++++++++++++++++++ drivers/gpu/nova-core/gsp/fw.rs | 4 + 4 files changed, 210 insertions(+), 3 deletions(-)drivers/gpu/nova-core/gsp.rs +0
-0
drivers/gpu/nova-core/gsp.rs line 19
Quoted 4 lines
drivers/gpu/nova-core/gsp.rs +1
-0@@ -16,6 +16,7 @@pub (crate )mod cmdq;pub (crate )mod commands; +mod continuation;
Looking at this series it seems more logical to have continuation under cmdq than just gsp.
Nothing in gsp makes use of it, as it is an implementation detail of the command queue. And that way the pub(super) exports would be perfectly scoped to their user.
Re-reading my review of v3, I am the one who suggested to put it under gsp - so this is my mistake.
No need to resend just for that, I can fix when applying and this should have no impact on the patches that come above it.
Giving it a few days to gather reviews, but after a first skim this looks ready to me.
Re: [PATCH v4 8/9] gpu: nova-core: gsp: support large RPCs via continuation record
Quoted 35 lines · Alexandre Courbot
Quoted 22 lines · Eliot Courtney
Splits large RPCs if necessary and sends the remaining parts using continuation records. RPCs that do not need continuation records continue to write directly into the command buffer. Ones that do write into a staging buffer first, so there is one copy.
Continuation record for receive is not necessary to support at the moment because those replies do not need to be read and are currently drained by retrying
receive_msgon ERANGE.Signed-off-by Eliot Courtney <[email protected]>--- drivers/gpu/nova-core/gsp.rs | 1 + drivers/gpu/nova-core/gsp/cmdq.rs | 41 +++++++- drivers/gpu/nova-core/gsp/continuation.rs | 167 ++++++++++++++++++++++++++++++ drivers/gpu/nova-core/gsp/fw.rs | 4 + 4 files changed, 210 insertions(+), 3 deletions(-)drivers/gpu/nova-core/gsp.rs +0
-0drivers/gpu/nova-core/gsp.rs line 19
Quoted 4 lines
drivers/gpu/nova-core/gsp.rs +1
-0@@ -16,6 +16,7 @@pub (crate )mod cmdq;pub (crate )mod commands; +mod continuation;Looking at this series it seems more logical to have
continuationundercmdqthan justgsp.Nothing in
gspmakes use of it, as it is an implementation detail of the command queue. And that way thepub(super)exports would be perfectly scoped to their user.
Quoted 5 lines
Re-reading my review of v3, I am the one who suggested to put it under
gsp- so this is my mistake.No need to resend just for that, I can fix when applying and this should have no impact on the patches that come above it.
I think we might have one more round on this so for now I have made this change locally and will be in the next version.
PATCH v4 9/9 gpu: nova-core: gsp: add tests for continuation records
In reply to Eliot CourtneyAdd tests for continuation record splitting. They cover boundary conditions at the split points to make sure the right number of continuation records are made. They also check that the data concatenated is correct.
--- drivers/gpu/nova-core/gsp/continuation.rs | 138 ++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+)
drivers/gpu/nova-core/gsp/continuation.rs +138 -0
@@ -165,3 +165,141 @@ fn init_variable_payload( dst.write_all (&self.payload) } } + +#[kunit_tests(nova_core_gsp_continuation)] +mod tests { +use super ::*; + +use kernel::transmute::{ +AsBytes , +FromBytes ,// + }; + +/// Non-zero-sized command header for testing. +#[repr( C )] +#[derive( Clone , Copy , Zeroable )] +struct TestHeader ([u8 ;64 ]); + +// SAFETY: `TestHeader` is a plain array of bytes for which all bit patterns are valid. +unsafe impl FromBytes for TestHeader {} + +// SAFETY: `TestHeader` is a plain array of bytes for which all bit patterns are valid. +unsafe impl AsBytes for TestHeader {} + +struct TestPayload { + data:KVVec <u8 >, + } + +impl TestPayload { +fn generate_pattern (len:usize ) ->Result <KVVec <u8 >> { +let mut data =KVVec ::with_capacity (len,GFP_KERNEL )?; +for iin 0 ..len { +// Mix in higher bits so the pattern does not repeat every 256 bytes. + data.push ((i ^ (i >>8 ))as u8 ,GFP_KERNEL )?; + } +Ok (data) + } + +fn new (len:usize ) ->Result <Self > { +Ok (Self { + data:Self ::generate_pattern (len)?, + }) + } + } + +impl CommandToGsp for TestPayload { +const FUNCTION :MsgFunction =MsgFunction ::Nop ; +type Command =TestHeader ; +type InitError =Infallible ; + +fn init (&self) ->impl Init <Self ::Command ,Self ::InitError > { +TestHeader ::init_zeroed () + } + +fn variable_payload_len (&self) ->usize { + self.data.len () + } + +fn init_variable_payload ( + &self, + dst: &mut SBufferIter <core::array::IntoIter <&mut [u8 ],2 >>, + ) ->Result { + dst.write_all (self.data.as_slice ()) + } + } + +/// Maximum variable payload size that fits in the first command alongside the header. +const MAX_FIRST_PAYLOAD :usize =SplitState ::<TestPayload >::MAX_FIRST_PAYLOAD ; + +fn read_payload (cmd:impl CommandToGsp ) ->Result <KVVec <u8 >> { +let len = cmd.variable_payload_len (); +let mut buf =KVVec ::from_elem (0u8 , len,GFP_KERNEL )?; +let mut sbuf =SBufferIter ::new_writer ([buf.as_mut_slice (), &mut []]); + cmd.init_variable_payload (&mut sbuf)?; +drop (sbuf); +Ok (buf) + } + +struct SplitTest { + payload_size:usize , + num_continuations:usize , + } + +fn check_split (t:SplitTest ) ->Result { +let payload =TestPayload ::new (t.payload_size)?; +let mut num_continuations =0 ; + +let buf =match SplitState ::new (payload)? { +SplitState ::Single (cmd) =>read_payload (cmd)?, +SplitState ::Split (cmd,mut continuations) => { +let mut buf =read_payload (cmd)?; +assert! (size_of ::<TestHeader >() + buf.len () <=MAX_CMD_SIZE ); + +while let Some (cont) = continuations.next () { +let payload =read_payload (cont)?; +assert! (payload.len () <=MAX_CMD_SIZE ); + buf.extend_from_slice (&payload,GFP_KERNEL )?; + num_continuations +=1 ; + } + + buf + } + }; + +assert_eq! (num_continuations, t.num_continuations); +assert_eq! ( + buf.as_slice (), +TestPayload ::generate_pattern (t.payload_size)?.as_slice () + ); +Ok (()) + } + +#[test] +fn split_command () ->Result { +check_split (SplitTest { + payload_size:0 , + num_continuations:0 , + })?; +check_split (SplitTest { + payload_size:MAX_FIRST_PAYLOAD , + num_continuations:0 , + })?; +check_split (SplitTest { + payload_size:MAX_FIRST_PAYLOAD +1 , + num_continuations:1 , + })?; +check_split (SplitTest { + payload_size:MAX_FIRST_PAYLOAD +MAX_CMD_SIZE , + num_continuations:1 , + })?; +check_split (SplitTest { + payload_size:MAX_FIRST_PAYLOAD +MAX_CMD_SIZE +1 , + num_continuations:2 , + })?; +check_split (SplitTest { + payload_size:MAX_FIRST_PAYLOAD +MAX_CMD_SIZE *3 +MAX_CMD_SIZE /2 , + num_continuations:4 , + })?; +Ok (()) + } +}
Signature · 1 line
2.53.0