Re: [PATCH v3 8/9] gpu: nova-core: gsp: support large RPCs via continuation record

["Alexandre Courbot" <acourbot@nvidia.com>]

Hi Eliot,

On Thu Feb 26, 2026 at 8:45 PM JST, Eliot Courtney wrote:
<snip>
> @@ -588,6 +592,39 @@ pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result
>          Ok(())
>      }
>  
> +    /// Sends `command` to the GSP.
> +    ///
> +    /// The command may be split into multiple messages if it is large.
> +    ///
> +    /// # Errors
> +    ///
> +    /// - `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.
> +    ///
> +    /// Error codes returned by the command initializers are propagated as-is.
> +    pub(crate) fn send_command<M>(&mut self, bar: &Bar0, command: M) -> Result
> +    where
> +        M: CommandToGsp,
> +        Error: From<M::InitError>,
> +    {
> +        let mut state = SplitState::new(&command)?;
> +
> +        self.send_single_command(bar, state.command(command))?;

As we discussed offline these two lines were bothering me a bit, because
we pass `command` twice and there is a possibility (although purely
hypothetical) of API misuse. I think I found a way around it: we turn
`SplitState` into an enum with a `Single` variant, that contains the
original command, and a `Split` one, which contains the truncated
initial command and its continuation records.

This simple change cascades into more simplifications in the new types
introduced by this patch: `SplitCommand` is not an enum anymore, but the
original command with a shorter payload. And the continuation records
are their own self-contained type. This is achieved by allocating two
`KVVec`s when we split, and taking advantage of the `SBuffer` we
conveniently have at hand to fill them both.

I have pushed a branch with this idea implemented on top of yours in [1]
- please check it, but I think it brings a nice (if small) incremental
improvement. It removes the API misuse potential, makes every type
purely single-purpose, and doesn't need `PhantomData` or lifetimes,
making it simpler overall IMHO.

[1] https://github.com/Gnurou/linux/tree/review/continuations

> +
> +        while let Some(continuation) = state.next_continuation_record() {
> +            dev_dbg!(
> +                &self.dev,
> +                "GSP RPC: send continuation: size=0x{:x}\n",
> +                command_size(&continuation),
> +            );

`send_single_command` should already print the command, so I don't think
we need this additional debug print?

> +            // Turbofish needed because the compiler cannot infer M here.
> +            self.send_single_command::<ContinuationRecord<'_>>(bar, continuation)?;
> +        }
> +
> +        Ok(())
> +    }
> +
>      /// Wait for a message to become available on the message queue.
>      ///
>      /// This works purely at the transport layer and does not interpret or validate the message
> diff --git a/drivers/gpu/nova-core/gsp/commands.rs b/drivers/gpu/nova-core/gsp/commands.rs
> index 8f270eca33be..6ffd0b9cbf05 100644
> --- a/drivers/gpu/nova-core/gsp/commands.rs
> +++ b/drivers/gpu/nova-core/gsp/commands.rs
> @@ -4,6 +4,7 @@
>      array,
>      convert::Infallible,
>      ffi::FromBytesUntilNulError,
> +    marker::PhantomData,
>      str::Utf8Error, //
>  };
>  
> @@ -22,13 +23,16 @@
>      driver::Bar0,
>      gsp::{
>          cmdq::{
> +            command_size,
>              Cmdq,
>              CommandToGsp,
>              MessageFromGsp, //
>          },
>          fw::{
>              commands::*,
> -            MsgFunction, //
> +            GspMsgElement,
> +            MsgFunction,
> +            GSP_MSG_QUEUE_ELEMENT_SIZE_MAX, //
>          },
>      },
>      sbuffer::SBufferIter,
> @@ -242,3 +246,141 @@ pub(crate) fn get_gsp_info(cmdq: &mut Cmdq, bar: &Bar0) -> Result<GetGspStaticIn
>          }
>      }
>  }
> +
> +/// The `ContinuationRecord` command.
> +pub(crate) struct ContinuationRecord<'a> {

These new types are to be used by the command queue, and we don't want
to use them elsewhere, so `pub(super)` seems more appropriate to me.

And actually, since they are more command queue infrastructure than pure
"commands" that fulfill a given purpose, I'd suggest moving them into
their own sub-module of `gsp` (named `continuation` or `split` maybe?).
That way they don't get in the way of readers who just want to learn
about GSP commands.