Re: [PATCH 00/19] rust: QObject and QAPI bindings

[Paolo Bonzini <pbonzini@redhat.com>]

On 10/10/25 17:09, Paolo Bonzini wrote:
> This adds two related parts of the Rust bindings:
> 
> - QAPI code generator that creates Rust structs from the JSON
>    description.  The structs are *not* ABI compatible with the
>    C ones, instead they use native Rust data types.
> 
> - QObject bindings and (de)serialization support, which can be used to
>    convert QObjects to and from QAPI structs.
> 
> Unfortunately Rust code is not able to use visitors, other than by
> creating an intermediate QObject.  This is because of the different
> architecture of serde vs. QAPI visitors, and because visitor's
> dual-purpose functions, where the same function is used by both input and
> output visitors, rely heavily on the structs using the same representation
> as the visitor arguments (for example NUL-terminated strings).
> 
> The serde format implementation was co-authored by me and Marc-André.
> Marc-André did all the bug fixing and integration testing.
> 
> As an example of how this would be used, the marshaling functions for
> QMP commands would look like this:
> 
> fn qmp_marshal_query_stats(args: *mut QDict,
>      retp: *mut *mut QObject, errp: *mut *mut Error)
> {
>      let qobj = unsafe { QObject::cloned_from_raw(args.cast()) };
> 
>      let result = from_qobject::<StatsFilter>(qobj)
>           .map_err(anyhow::Error::from)
>           .and_then(qmp_query_stats)
>           .and_then(|ret| to_qobject::<Vec<StatsResult>>(ret).map_err(anyhow::Error::from));
> 
>      match qmp_marshal_query_stats_rs(qobj) {
>          Ok(ret) => unsafe { *retp = ret.into_raw(); },
>          Err(e) => unsafe { crate::Error::from(e).propagate(errp) },
>      }
> }
> 
> As a small extra, patches 1 and 2 rework a bit the error implementation
> so that it is possible to convert any Rust error into a QEMU one.  This
> is because we noticed that we had to add several From<> implementations
> to convert e.g. NulError or serde errors into util::Error.
> 
> The price is that it's a bit harder to convert *strings* into errors;
> therefore, the first patch adds a macro wrapper for
> "if !cond { return Err(...) }", where the dots build an error from a
> formatted string.
Ping.

Paolo