Re: [PATCH v5 09/14] gpu: nova-core: gsp: cmdq: split the transport part of the receive path

["Eliot Courtney" <ecourtney@nvidia.com>]

On Tue Oct 20, 2026 at 7:08 PM JST, Alexandre Courbot wrote:
> `receive_msg` currently handles both the transport and RPC layers.
> Retire it and split its logic between the new `consume_element`, a
> transport-level method which passes the parsed message contents to a
> closure before advancing the CPU read pointer past it, and the
> already-existing `await_msg`, which calls `consume_element` with a
> closure matching the RPC message.
>
> This introduces a small behavioral change: a matched RPC message that is
> too short to contain the message component itself no longer stalls the
> queue. This behavior is justified because it fixes an inconsistency:
> unmatched RPC messages were always skipped, whereas matched RPC messages
> could block the queue if they were too short. While a misconstructed RPC
> message is a problem, it is not a fatal queue error as long as the
> transport framing and checksum are valid.
>
> Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
> ---

[...]

> -    /// Receive a message from the GSP.
> +    /// Wait for the next element on the message queue, pass it to `f`, advance the read pointer
> +    /// past the message, and returns the result of `f`.
>      ///
> -    /// A message whose function code is `M::FUNCTION` is decoded and returned. Any other message
> -    /// is logged as an event.
> -    ///
> -    /// The read pointer is always advanced past the message, regardless of whether it matched.
> +    /// The read pointer advances regardless of whether `f` succeeds or not.
>      ///
>      /// # Errors
>      ///
>      /// - `ETIMEDOUT` if `timeout` has elapsed before any message becomes available.
> -    /// - `EIO` if a message fails framing or checksum validation.
> -    /// - `ENOMSG` if the message was not the awaited reply.
> +    /// - `EIO` if a message fails framing or checksum validation. In this case, the read pointer
> +    ///   does not advance and the queue is stalled. This is a fatal error.
>      ///
> -    /// Error codes returned by [`MessageFromGsp::read`] are propagated as-is.
> -    fn receive_msg<M: MessageFromGsp>(&mut self, timeout: Delta) -> Result<M>
> -    where
> -        // This allows all error types, including `Infallible`, to be used for `M::InitError`.
> -        Error: From<M::InitError>,
> -    {
> +    /// If an error is returned, then `f` has not been called.

optional nit: Clarify in a comment that w.r.t. `EIO` and `f` not being
called, that only applies for the outermost Err. i.e., we do have
R = Result<>, so we have Result<Result<>> but we're only talking about
the outer (transport) Result here. Maybe one way to clarify this is
that `R` contains the output of the message layer and may itself
be a Result<>, and this function returns a Result for the transport
layer. Not sure of the best way to phrase it but you know what I mean.

Reviewed-by: Eliot Courtney <ecourtney@nvidia.com>