This RFC series contains some simple patches I've been sitting on for
some months to allow tracing in rust devices in a similar matter to C,
only it's done via a proc-macro codegen instead of using tracetool
script or equivalent.

It also adds the same tracepoints as C in the pl011 device (cc: Philippe)

TODOS:
- Do not allocate string when calling ::qemu_api::log::LogGuard::log_fmt
  (See commit message)
- Properly handle&report errors in proc-macro
- Clean up proc-macro code
- Add test for proc-macro
- Add dev documentation

Signed-off-by: Manos Pitsidianakis <manos.pitsidianakis@linaro.org>
---
Manos Pitsidianakis (5):
      rust/bindings: add trace headers
      rust/qemu-api/log: add Log::Trace variant
      rust/qemu-api-macros: Add #[trace_events] macro
      rust/pl011: impl Copy, Clone for RegisterOffset
      rust/pl011: add trace events

 rust/hw/char/pl011/src/device.rs    |  28 +++++++-
 rust/hw/char/pl011/src/lib.rs       |  43 +++++++++++
 rust/hw/char/pl011/src/registers.rs |   2 +-
 rust/qemu-api-macros/src/lib.rs     | 140 +++++++++++++++++++++++++++++++++++-
 rust/qemu-api/src/bindings.rs       |   3 +
 rust/qemu-api/src/log.rs            |   4 ++
 rust/qemu-api/wrapper.h             |   2 +
 7 files changed, 215 insertions(+), 7 deletions(-)
---
base-commit: e5859141b9b6aec9e0a14dacedc9f02fe2f15844
change-id: 20250804-rust_trace-8558fc98ec88

--
γαῖα πυρί μιχθήτω

On Mon, Aug 04, 2025 at 04:47:13PM +0300, Manos Pitsidianakis wrote:
> This RFC series contains some simple patches I've been sitting on for
> some months to allow tracing in rust devices in a similar matter to C,
> only it's done via a proc-macro codegen instead of using tracetool
> script or equivalent.

IIUC, this series is only emitting the traces events via the
qemu_log function, and so feels like it is missing the benefit
of tracing, vs the traditional logging framework.

In our RHEL & Fedora distro builds we disable the log backend
and enable dtrace, so that we have fully dynamic tracing and
observability across the kernel, qemu, libvirt and other
components with dtrace integration.



With regards,
Daniel
-- 
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|

On Tue, Aug 5, 2025 at 7:05 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
>
> On Mon, Aug 04, 2025 at 04:47:13PM +0300, Manos Pitsidianakis wrote:
> > This RFC series contains some simple patches I've been sitting on for
> > some months to allow tracing in rust devices in a similar matter to C,
> > only it's done via a proc-macro codegen instead of using tracetool
> > script or equivalent.
>
> IIUC, this series is only emitting the traces events via the
> qemu_log function, and so feels like it is missing the benefit
> of tracing, vs the traditional logging framework.
>
> In our RHEL & Fedora distro builds we disable the log backend
> and enable dtrace, so that we have fully dynamic tracing and
> observability across the kernel, qemu, libvirt and other
> components with dtrace integration.

Hi Daniel,

Thanks for the insight! Do you have any points where I should look at
the trace implementation for how the different backends are supported?

So I think there's already work in progress to support proper tracing
for Rust, I only sent this as a temporary fixup to provide some kind
of parity between C and Rust implementations until a proper, better
solution is available that can replace it.


-- 
Manos Pitsidianakis
Emulation and Virtualization Engineer at Linaro Ltd

On Tue, Aug 05, 2025 at 07:25:39PM +0300, Manos Pitsidianakis wrote:
> On Tue, Aug 5, 2025 at 7:05 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> >
> > On Mon, Aug 04, 2025 at 04:47:13PM +0300, Manos Pitsidianakis wrote:
> > > This RFC series contains some simple patches I've been sitting on for
> > > some months to allow tracing in rust devices in a similar matter to C,
> > > only it's done via a proc-macro codegen instead of using tracetool
> > > script or equivalent.
> >
> > IIUC, this series is only emitting the traces events via the
> > qemu_log function, and so feels like it is missing the benefit
> > of tracing, vs the traditional logging framework.
> >
> > In our RHEL & Fedora distro builds we disable the log backend
> > and enable dtrace, so that we have fully dynamic tracing and
> > observability across the kernel, qemu, libvirt and other
> > components with dtrace integration.
> 
> Hi Daniel,
> 
> Thanks for the insight! Do you have any points where I should look at
> the trace implementation for how the different backends are supported?
> 
> So I think there's already work in progress to support proper tracing
> for Rust, I only sent this as a temporary fixup to provide some kind
> of parity between C and Rust implementations until a proper, better
> solution is available that can replace it.

Can the rust code not easily consume the existing functions in the
trace.h files generated for the C code as a short-term solution ?

It would not benefit from the code inlining in the same way as C
would, but it would at least give feature parity for tracing with
all the trace backends are available.

Then, we can look at optimizing with a pure rust impl of some
backends at a later date, to regain what we lost from lack of
inlining ?

With regards,
Daniel
-- 
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|

On Tue, Aug 5, 2025 at 7:43 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
>
> On Tue, Aug 05, 2025 at 07:25:39PM +0300, Manos Pitsidianakis wrote:
> > On Tue, Aug 5, 2025 at 7:05 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> > >
> > > On Mon, Aug 04, 2025 at 04:47:13PM +0300, Manos Pitsidianakis wrote:
> > > > This RFC series contains some simple patches I've been sitting on for
> > > > some months to allow tracing in rust devices in a similar matter to C,
> > > > only it's done via a proc-macro codegen instead of using tracetool
> > > > script or equivalent.
> > >
> > > IIUC, this series is only emitting the traces events via the
> > > qemu_log function, and so feels like it is missing the benefit
> > > of tracing, vs the traditional logging framework.
> > >
> > > In our RHEL & Fedora distro builds we disable the log backend
> > > and enable dtrace, so that we have fully dynamic tracing and
> > > observability across the kernel, qemu, libvirt and other
> > > components with dtrace integration.
> >
> > Hi Daniel,
> >
> > Thanks for the insight! Do you have any points where I should look at
> > the trace implementation for how the different backends are supported?
> >
> > So I think there's already work in progress to support proper tracing
> > for Rust, I only sent this as a temporary fixup to provide some kind
> > of parity between C and Rust implementations until a proper, better
> > solution is available that can replace it.
>
> Can the rust code not easily consume the existing functions in the
> trace.h files generated for the C code as a short-term solution ?
>
> It would not benefit from the code inlining in the same way as C
> would, but it would at least give feature parity for tracing with
> all the trace backends are available.
>
> Then, we can look at optimizing with a pure rust impl of some
> backends at a later date, to regain what we lost from lack of
> inlining ?

It can, but we'd need to add extra intermediate steps to convert the
trace headers into Rust equivalent code, so it's not ideal.

I tried to generate code exactly like the generated trace headers
though, so I'm not sure what is missing to be honest (hence my
previous email question). The generated code generates TraceEvents and
registers them with trace_event_register_group. What else is missing
to support e.g. dtrace?

Thanks in advance,

-- 
Manos Pitsidianakis
Emulation and Virtualization Engineer at Linaro Ltd

On Tue, Aug 05, 2025 at 07:47:39PM +0300, Manos Pitsidianakis wrote:
> On Tue, Aug 5, 2025 at 7:43 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> >
> > On Tue, Aug 05, 2025 at 07:25:39PM +0300, Manos Pitsidianakis wrote:
> > > On Tue, Aug 5, 2025 at 7:05 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> > > >
> > > > On Mon, Aug 04, 2025 at 04:47:13PM +0300, Manos Pitsidianakis wrote:
> > > > > This RFC series contains some simple patches I've been sitting on for
> > > > > some months to allow tracing in rust devices in a similar matter to C,
> > > > > only it's done via a proc-macro codegen instead of using tracetool
> > > > > script or equivalent.
> > > >
> > > > IIUC, this series is only emitting the traces events via the
> > > > qemu_log function, and so feels like it is missing the benefit
> > > > of tracing, vs the traditional logging framework.
> > > >
> > > > In our RHEL & Fedora distro builds we disable the log backend
> > > > and enable dtrace, so that we have fully dynamic tracing and
> > > > observability across the kernel, qemu, libvirt and other
> > > > components with dtrace integration.
> > >
> > > Hi Daniel,
> > >
> > > Thanks for the insight! Do you have any points where I should look at
> > > the trace implementation for how the different backends are supported?
> > >
> > > So I think there's already work in progress to support proper tracing
> > > for Rust, I only sent this as a temporary fixup to provide some kind
> > > of parity between C and Rust implementations until a proper, better
> > > solution is available that can replace it.
> >
> > Can the rust code not easily consume the existing functions in the
> > trace.h files generated for the C code as a short-term solution ?
> >
> > It would not benefit from the code inlining in the same way as C
> > would, but it would at least give feature parity for tracing with
> > all the trace backends are available.
> >
> > Then, we can look at optimizing with a pure rust impl of some
> > backends at a later date, to regain what we lost from lack of
> > inlining ?
> 
> It can, but we'd need to add extra intermediate steps to convert the
> trace headers into Rust equivalent code, so it's not ideal.
> 
> I tried to generate code exactly like the generated trace headers
> though, so I'm not sure what is missing to be honest (hence my
> previous email question). The generated code generates TraceEvents and
> registers them with trace_event_register_group. What else is missing
> to support e.g. dtrace?

'trace_event_register_group' is essentially irrelevant for the
fully dynamic trace backends like dtrace - that's only used for
the backends whose output is controlled by QEMU monitor commands
/ command line arguments.

In the dtrace case the binary gets instructions which are a squence
of nops normally, and dtrace tool gets the kernel to live patch the
binary at runtime to put in a jump for any probes that are being
watched.

Take a look at the generated files <build-dir>/trace/trace-*.h when
using the different '--enable-trace-backends=...' options.

eg taking the trace-crypto.h header, with 'log' backend we see it
emits

   if (trace_event_get_state(TRACE_QCRYPTO_TLS_SESSION_CHECK_CREDS) && qemu_loglevel_mask(LOG_TRACE)) {
#line 23 "../crypto/trace-events"
        qemu_log("qcrypto_tls_session_check_creds " "TLS session check creds session=%p status=%s" "\n", session, status);
#line 372 "trace/trace-crypto.h"
    }

but with dtrace it emits

    QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS(session, status);

which is a referencing a macro created by the external 'dtrace' binary,
which in the Linux case ends up looking like

  #if defined STAP_SDT_V1
  #define QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS_ENABLED() __builtin_expect (qcrypto_tls_session_check_creds_semaphore, 0)
  #define qemu_qcrypto_tls_session_check_creds_semaphore qcrypto_tls_session_check_creds_semaphore
  #else
  #define QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS_ENABLED() __builtin_expect (qemu_qcrypto_tls_session_check_creds_semaphore, 0)
  #endif
  __extension__ extern unsigned short qemu_qcrypto_tls_session_check_creds_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes")));
  #define QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS(arg1, arg2) \
  DTRACE_PROBE2 (qemu, qcrypto_tls_session_check_creds, arg1, arg2)

you can end up enabling multiple trace backends concurrently too.

If you're thinking this is all rather complicated, you'd be right,
which is why for initial feature parity I figured the simplest is
likely to just wrap the existing QEMU inline probe function, so
Rust doesn't need to know about the different backends... yet...

FWIW, the original DTrace authors created a Rust crate with native
rust integration of dynamic probes.

  https://github.com/oxidecomputer/usdt

I think that (somehow) we probably want to integrate that with QEMU
and its tracetool.

With regards,
Daniel
-- 
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|

Hello Daniel,


Thanks very much for the write up, I think I understand it a lot better now :)

On Tue, Aug 5, 2025 at 8:54 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
>
> On Tue, Aug 05, 2025 at 07:47:39PM +0300, Manos Pitsidianakis wrote:
> > On Tue, Aug 5, 2025 at 7:43 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> > >
> > > On Tue, Aug 05, 2025 at 07:25:39PM +0300, Manos Pitsidianakis wrote:
> > > > On Tue, Aug 5, 2025 at 7:05 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> > > > >
> > > > > On Mon, Aug 04, 2025 at 04:47:13PM +0300, Manos Pitsidianakis wrote:
> > > > > > This RFC series contains some simple patches I've been sitting on for
> > > > > > some months to allow tracing in rust devices in a similar matter to C,
> > > > > > only it's done via a proc-macro codegen instead of using tracetool
> > > > > > script or equivalent.
> > > > >
> > > > > IIUC, this series is only emitting the traces events via the
> > > > > qemu_log function, and so feels like it is missing the benefit
> > > > > of tracing, vs the traditional logging framework.
> > > > >
> > > > > In our RHEL & Fedora distro builds we disable the log backend
> > > > > and enable dtrace, so that we have fully dynamic tracing and
> > > > > observability across the kernel, qemu, libvirt and other
> > > > > components with dtrace integration.
> > > >
> > > > Hi Daniel,
> > > >
> > > > Thanks for the insight! Do you have any points where I should look at
> > > > the trace implementation for how the different backends are supported?
> > > >
> > > > So I think there's already work in progress to support proper tracing
> > > > for Rust, I only sent this as a temporary fixup to provide some kind
> > > > of parity between C and Rust implementations until a proper, better
> > > > solution is available that can replace it.
> > >
> > > Can the rust code not easily consume the existing functions in the
> > > trace.h files generated for the C code as a short-term solution ?
> > >
> > > It would not benefit from the code inlining in the same way as C
> > > would, but it would at least give feature parity for tracing with
> > > all the trace backends are available.
> > >
> > > Then, we can look at optimizing with a pure rust impl of some
> > > backends at a later date, to regain what we lost from lack of
> > > inlining ?
> >
> > It can, but we'd need to add extra intermediate steps to convert the
> > trace headers into Rust equivalent code, so it's not ideal.
> >
> > I tried to generate code exactly like the generated trace headers
> > though, so I'm not sure what is missing to be honest (hence my
> > previous email question). The generated code generates TraceEvents and
> > registers them with trace_event_register_group. What else is missing
> > to support e.g. dtrace?
>
> 'trace_event_register_group' is essentially irrelevant for the
> fully dynamic trace backends like dtrace - that's only used for
> the backends whose output is controlled by QEMU monitor commands
> / command line arguments.
>
> In the dtrace case the binary gets instructions which are a squence
> of nops normally, and dtrace tool gets the kernel to live patch the
> binary at runtime to put in a jump for any probes that are being
> watched.
>
> Take a look at the generated files <build-dir>/trace/trace-*.h when
> using the different '--enable-trace-backends=...' options.
>
> eg taking the trace-crypto.h header, with 'log' backend we see it
> emits
>
>    if (trace_event_get_state(TRACE_QCRYPTO_TLS_SESSION_CHECK_CREDS) && qemu_loglevel_mask(LOG_TRACE)) {
> #line 23 "../crypto/trace-events"
>         qemu_log("qcrypto_tls_session_check_creds " "TLS session check creds session=%p status=%s" "\n", session, status);
> #line 372 "trace/trace-crypto.h"
>     }
>
> but with dtrace it emits
>
>     QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS(session, status);
>
> which is a referencing a macro created by the external 'dtrace' binary,
> which in the Linux case ends up looking like
>
>   #if defined STAP_SDT_V1
>   #define QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS_ENABLED() __builtin_expect (qcrypto_tls_session_check_creds_semaphore, 0)
>   #define qemu_qcrypto_tls_session_check_creds_semaphore qcrypto_tls_session_check_creds_semaphore
>   #else
>   #define QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS_ENABLED() __builtin_expect (qemu_qcrypto_tls_session_check_creds_semaphore, 0)
>   #endif
>   __extension__ extern unsigned short qemu_qcrypto_tls_session_check_creds_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes")));
>   #define QEMU_QCRYPTO_TLS_SESSION_CHECK_CREDS(arg1, arg2) \
>   DTRACE_PROBE2 (qemu, qcrypto_tls_session_check_creds, arg1, arg2)
>
> you can end up enabling multiple trace backends concurrently too.
>
> If you're thinking this is all rather complicated, you'd be right,
> which is why for initial feature parity I figured the simplest is
> likely to just wrap the existing QEMU inline probe function, so
> Rust doesn't need to know about the different backends... yet...

Yes, that indeed makes sense.  Generated C trace headers statically
linked to a standalone trace crate library for each subsystem, that
rust qemu crates can link to in return is the cleanest solution for
this approach IMHO, because doing this kind of codegen via macros
needs interaction with meson to generate the C sources and then run
bindgen all while compiling this one crate which is a single meson lib
target.

It might be possible to generate the equivalent of the C code for each
backend just like this RFC generates only the log backend code, I'll
take a look out of curiosity...

>
> FWIW, the original DTrace authors created a Rust crate with native
> rust integration of dynamic probes.
>
>   https://github.com/oxidecomputer/usdt
>
> I think that (somehow) we probably want to integrate that with QEMU
> and its tracetool.

On 8/5/25 22:06, Manos Pitsidianakis wrote:
>> If you're thinking this is all rather complicated, you'd be right,
>> which is why for initial feature parity I figured the simplest is
>> likely to just wrap the existing QEMU inline probe function, so
>> Rust doesn't need to know about the different backends... yet...

It's not too hard to add individual backends (other than dtrace---see 
below--and ust which doesn't build for me(*) and I wanted to deprecate). 
  Tanish is pretty close to being able to post initial work.

> Yes, that indeed makes sense.  Generated C trace headers statically
> linked to a standalone trace crate library for each subsystem, that
> rust qemu crates can link to in return is the cleanest solution for
> this approach IMHO, because doing this kind of codegen via macros
> needs interaction with meson to generate the C sources and then run
> bindgen all while compiling this one crate which is a single meson lib
> target.
> 
> It might be possible to generate the equivalent of the C code for each
> backend just like this RFC generates only the log backend code, I'll
> take a look out of curiosity...
>
>> FWIW, the original DTrace authors created a Rust crate with native
>> rust integration of dynamic probes.
>>
>>    https://github.com/oxidecomputer/usdt
>>
>> I think that (somehow) we probably want to integrate that with QEMU
>> and its tracetool.

This unfortunately only works for macOS and Solaris.  It also has quite 
a few dependencies (~25) on other crates.  There is also a "probe" crate 
(https://github.com/cuviper/probe-rs) that is minimal and (currently) 
specific to Linux, which is what I planned to use.

By the way, while I like the idea of using Rust format strings, there 
are parts of tracetool (e.g. format/log_stap.py) that need the printf 
strings, and also backends (e.g. backend/syslog.py) that call into libc 
and therefore need to use printf format strings.  So I think we're stuck.

Paolo

(*) that's because this tracepoint:

visit_type_str(void *v, const char *name, char **obj) "v=%p name=%s obj=%p

incorrectly handles 'char **' as a string.  The breakage has been there 
since 2016, though probably it's only more recent versions of ust that 
actually fail to compile and until then the bug was latent until you 
enabled this tracepoint.  But it seems unlikely that anyone has used the 
ust backend recently.

On Wed, Aug 06, 2025 at 11:02:53AM +0200, Paolo Bonzini wrote:
> On 8/5/25 22:06, Manos Pitsidianakis wrote:
> > > If you're thinking this is all rather complicated, you'd be right,
> > > which is why for initial feature parity I figured the simplest is
> > > likely to just wrap the existing QEMU inline probe function, so
> > > Rust doesn't need to know about the different backends... yet...
> 
> It's not too hard to add individual backends (other than dtrace---see
> below--and ust which doesn't build for me(*) and I wanted to deprecate).
> Tanish is pretty close to being able to post initial work.

If we want to drop some backends that's fine, as IMHO we've got
needlessly many there.

> > Yes, that indeed makes sense.  Generated C trace headers statically
> > linked to a standalone trace crate library for each subsystem, that
> > rust qemu crates can link to in return is the cleanest solution for
> > this approach IMHO, because doing this kind of codegen via macros
> > needs interaction with meson to generate the C sources and then run
> > bindgen all while compiling this one crate which is a single meson lib
> > target.
> > 
> > It might be possible to generate the equivalent of the C code for each
> > backend just like this RFC generates only the log backend code, I'll
> > take a look out of curiosity...
> > 
> > > FWIW, the original DTrace authors created a Rust crate with native
> > > rust integration of dynamic probes.
> > > 
> > >    https://github.com/oxidecomputer/usdt
> > > 
> > > I think that (somehow) we probably want to integrate that with QEMU
> > > and its tracetool.
> 
> This unfortunately only works for macOS and Solaris.  It also has quite a
> few dependencies (~25) on other crates.  There is also a "probe" crate
> (https://github.com/cuviper/probe-rs) that is minimal and (currently)
> specific to Linux, which is what I planned to use.
> 
> By the way, while I like the idea of using Rust format strings, there are
> parts of tracetool (e.g. format/log_stap.py) that need the printf strings,
> and also backends (e.g. backend/syslog.py) that call into libc and therefore
> need to use printf format strings.  So I think we're stuck.

Note, I would describe our format strings as printf-like/light. We certainly
do NOT allow the full range of C library formats, because we need to be able
to pass the format strings to systemtap, which is likewise merely printf-like.

Do don't really do any significant upfront validation on the format specifiers
beyond checking for invalid %m and newlines. In practical terms though the
only things we can use are

  %x %u %d %s %p

with optional 'l', 'll' or 'z' modifiers and digit precision for the int
formats. Anything beyond that will likely fail with systemtap. We ought
to move validation for this to the parsing phase to strongly enforce this
limited syntax.

IOW, in any tracetool format generator for rust, we could fairly easily
translate the format string from printf-like to rust style.

With regards,
Daniel
-- 
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|

On Wed, Aug 6, 2025 at 12:21 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
>
> On Wed, Aug 06, 2025 at 11:02:53AM +0200, Paolo Bonzini wrote:
> > On 8/5/25 22:06, Manos Pitsidianakis wrote:
> > > > If you're thinking this is all rather complicated, you'd be right,
> > > > which is why for initial feature parity I figured the simplest is
> > > > likely to just wrap the existing QEMU inline probe function, so
> > > > Rust doesn't need to know about the different backends... yet...
> >
> > It's not too hard to add individual backends (other than dtrace---see
> > below--and ust which doesn't build for me(*) and I wanted to deprecate).
> > Tanish is pretty close to being able to post initial work.
>
> If we want to drop some backends that's fine, as IMHO we've got
> needlessly many there.
>
> > > Yes, that indeed makes sense.  Generated C trace headers statically
> > > linked to a standalone trace crate library for each subsystem, that
> > > rust qemu crates can link to in return is the cleanest solution for
> > > this approach IMHO, because doing this kind of codegen via macros
> > > needs interaction with meson to generate the C sources and then run
> > > bindgen all while compiling this one crate which is a single meson lib
> > > target.
> > >
> > > It might be possible to generate the equivalent of the C code for each
> > > backend just like this RFC generates only the log backend code, I'll
> > > take a look out of curiosity...
> > >
> > > > FWIW, the original DTrace authors created a Rust crate with native
> > > > rust integration of dynamic probes.
> > > >
> > > >    https://github.com/oxidecomputer/usdt
> > > >
> > > > I think that (somehow) we probably want to integrate that with QEMU
> > > > and its tracetool.
> >
> > This unfortunately only works for macOS and Solaris.  It also has quite a
> > few dependencies (~25) on other crates.  There is also a "probe" crate
> > (https://github.com/cuviper/probe-rs) that is minimal and (currently)
> > specific to Linux, which is what I planned to use.
> >
> > By the way, while I like the idea of using Rust format strings, there are
> > parts of tracetool (e.g. format/log_stap.py) that need the printf strings,
> > and also backends (e.g. backend/syslog.py) that call into libc and thereforepar
> > need to use printf format strings.  So I think we're stuck.
>
> Note, I would describe our format strings as printf-like/light. We certainly
> do NOT allow the full range of C library formats, because we need to be able
> to pass the format strings to systemtap, which is likewise merely printf-like.

That simplifies things in a major way (printf specifiers are so
complex they are turing complete). It'd be trivial to parse and
convert into equivalent Rust formatting if you constraint specifiers
like you say.

>
> Do don't really do any significant upfront validation on the format specifiers
> beyond checking for invalid %m and newlines. In practical terms though the
> only things we can use are
>
>   %x %u %d %s %p
>
> with optional 'l', 'll' or 'z' modifiers and digit precision for the int
> formats. Anything beyond that will likely fail with systemtap. We ought
> to move validation for this to the parsing phase to strongly enforce this
> limited syntax.
>
> IOW, in any tracetool format generator for rust, we could fairly easily
> translate the format string from printf-like to rust style.
>
> With regards,
> Daniel
> --
> |: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
> |: https://libvirt.org         -o-            https://fstop138.berrange.com :|
> |: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|
>

Hello Paolo,

On Wed, Aug 6, 2025 at 12:03 PM Paolo Bonzini <pbonzini@redhat.com> wrote:
>
> On 8/5/25 22:06, Manos Pitsidianakis wrote:
> >> If you're thinking this is all rather complicated, you'd be right,
> >> which is why for initial feature parity I figured the simplest is
> >> likely to just wrap the existing QEMU inline probe function, so
> >> Rust doesn't need to know about the different backends... yet...
>
> It's not too hard to add individual backends (other than dtrace---see
> below--and ust which doesn't build for me(*) and I wanted to deprecate).
>   Tanish is pretty close to being able to post initial work.

Ack, I look forward to it :) I hope my RFC provides them some
inspiration on what things (not) to do.

Thanks,

>
> > Yes, that indeed makes sense.  Generated C trace headers statically
> > linked to a standalone trace crate library for each subsystem, that
> > rust qemu crates can link to in return is the cleanest solution for
> > this approach IMHO, because doing this kind of codegen via macros
> > needs interaction with meson to generate the C sources and then run
> > bindgen all while compiling this one crate which is a single meson lib
> > target.
> >
> > It might be possible to generate the equivalent of the C code for each
> > backend just like this RFC generates only the log backend code, I'll
> > take a look out of curiosity...
> >
> >> FWIW, the original DTrace authors created a Rust crate with native
> >> rust integration of dynamic probes.
> >>
> >>    https://github.com/oxidecomputer/usdt
> >>
> >> I think that (somehow) we probably want to integrate that with QEMU
> >> and its tracetool.
>
> This unfortunately only works for macOS and Solaris.  It also has quite
> a few dependencies (~25) on other crates.  There is also a "probe" crate
> (https://github.com/cuviper/probe-rs) that is minimal and (currently)
> specific to Linux, which is what I planned to use.
>
> By the way, while I like the idea of using Rust format strings, there
> are parts of tracetool (e.g. format/log_stap.py) that need the printf
> strings, and also backends (e.g. backend/syslog.py) that call into libc
> and therefore need to use printf format strings.  So I think we're stuck.
>
> Paolo
>
> (*) that's because this tracepoint:
>
> visit_type_str(void *v, const char *name, char **obj) "v=%p name=%s obj=%p
>
> incorrectly handles 'char **' as a string.  The breakage has been there
> since 2016, though probably it's only more recent versions of ust that
> actually fail to compile and until then the bug was latent until you
> enabled this tracepoint.  But it seems unlikely that anyone has used the
> ust backend recently.
>

-- 
Manos Pitsidianakis
Emulation and Virtualization Engineer at Linaro Ltd