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.
