On Fri, Aug 22, 2025 at 3:31 PM Paolo Bonzini <pbonz...@redhat.com> wrote:
>
> From: Tanish Desai <tanishdesa...@gmail.com>
>
> Generating .rs files makes it possible to support tracing in rust.
> This support comprises a new format, and common code that converts
> the C expressions in trace-events to Rust. In particular, types
> need to be converted, and PRI macros expanded. Fortunately, all
> common platforms have a known mapping of 8/16/32/64-bit integers
> to char/short/int/"long long": even if int64_t is equal to long,
> it is fine to change the format string from PRIx64's expansion
> "%lx" to "%llx". This makes it possible to have a static mapping
> from PRI macros to their expansion.
>
> As of this commit no backend generates Rust code, but it is already
> possible to use tracetool to generate Rust sources; they are not
> functional but they compile and contain tracepoint functions.
>
> Signed-off-by: Tanish Desai <tanishdesa...@gmail.com>
> [Move Rust argument conversion from Event to Arguments; string
> support. - Paolo]
> Signed-off-by: Paolo Bonzini <pbonz...@redhat.com>
> ---
> scripts/tracetool/__init__.py | 156 +++++++++++++++++++++++++++++++++
> scripts/tracetool/format/rs.py | 76 ++++++++++++++++
> 2 files changed, 232 insertions(+)
> create mode 100644 scripts/tracetool/format/rs.py
>
> diff --git a/scripts/tracetool/__init__.py b/scripts/tracetool/__init__.py
> index 1d5238a0843..0b8ec707332 100644
> --- a/scripts/tracetool/__init__.py
> +++ b/scripts/tracetool/__init__.py
> @@ -31,6 +31,49 @@ def error(*lines):
> error_write(*lines)
> sys.exit(1)
>
> +FMT_TOKEN = re.compile(r'''(?:
> + " ( (?: [^"\\] | \\[\\"abfnrt] | # a
> string literal
> + \\x[0-9a-fA-F][0-9a-fA-F]) *? ) "
> + | ( PRI [duixX] (?:8|16|32|64|PTR|MAX) ) # a
> PRIxxx macro
> + | \s+ # spaces
> (ignored)
> + )''', re.X)
> +
> +PRI_SIZE_MAP = {
> + '8': 'hh',
> + '16': 'h',
> + '32': '',
> + '64': 'll',
> + 'PTR': 't',
> + 'MAX': 'j',
> +}
> +
> +def expand_format_string(c_fmt, prefix=""):
(Pedantic comment) let's put type annotations in function signatures
when possible, these seem to handle `str` mostly so this should be
simple. This should catch basic errors like passing/returning `str |
None` or wrong types altogether.
> + def pri_macro_to_fmt(pri_macro):
> + assert pri_macro.startswith("PRI")
> + fmt_type = pri_macro[3] # 'd', 'i', 'u', or 'x'
> + fmt_size = pri_macro[4:] # '8', '16', '32', '64', 'PTR', 'MAX'
> +
> + size = PRI_SIZE_MAP.get(fmt_size, None)
> + if size is None:
> + raise Exception(f"unknown macro {pri_macro}")
> + return size + fmt_type
> +
> + result = prefix
> + pos = 0
> + while pos < len(c_fmt):
> + m = FMT_TOKEN.match(c_fmt, pos)
> + if not m:
> + print("No match at position", pos, ":", repr(c_fmt[pos:]),
> file=sys.stderr)
> + raise Exception("syntax error in trace file")
> + if m[1]:
> + substr = m[1]
> + elif m[2]:
> + substr = pri_macro_to_fmt(m[2])
> + else:
> + substr = ""
> + result += substr
> + pos = m.end()
> + return result
>
> out_lineno = 1
> out_filename = '<none>'
> @@ -90,6 +133,48 @@ def out(*lines, **kwargs):
> "ptrdiff_t",
> ]
>
> +C_TYPE_KEYWORDS = {"int", "short", "long", "unsigned", "char"}
> +
> +C_TO_RUST_TYPE_MAP = {
> + "int": "std::ffi::c_int",
> + "long": "std::ffi::c_long",
> + "long long": "std::ffi::c_longlong",
> + "short": "std::ffi::c_short",
> + "char": "std::ffi::c_char",
> + "bool": "bool",
> + "unsigned": "std::ffi::c_uint",
> + "unsigned long": "std::ffi::c_long",
> + "unsigned long long": "std::ffi::c_ulonglong",
> + "unsigned short": "std::ffi::c_ushort",
> + "unsigned char": "u8",
> + "int8_t": "i8",
> + "uint8_t": "u8",
> + "int16_t": "i16",
> + "uint16_t": "u16",
> + "int32_t": "i32",
> + "uint32_t": "u32",
> + "int64_t": "i64",
> + "uint64_t": "u64",
> + "void": "()",
> + "size_t": "usize",
> + "ssize_t": "isize",
> + "uintptr_t": "usize",
> + "ptrdiff_t": "isize",
> +}
> +
> +# Rust requires manual casting of <32-bit types when passing them to
> +# variable-argument functions.
> +RUST_VARARGS_SMALL_TYPES = {
> + "std::ffi::c_short",
> + "std::ffi::c_ushort",
> + "std::ffi::c_char",
> + "i8",
> + "u8",
> + "i16",
> + "u16",
> + "bool",
> +}
> +
> def validate_type(name):
> bits = name.split(" ")
> for bit in bits:
> @@ -105,6 +190,40 @@ def validate_type(name):
> "other complex pointer types should be "
> "declared as 'void *'" % name)
>
> +def c_type_to_rust(name):
> + ptr = False
> + const = False
> + name = name.rstrip()
> + if name[-1] == '*':
> + name = name[:-1].rstrip()
> + ptr = True
> + if name[-1] == '*':
> + # pointers to pointers are the same as void*
> + name = "void"
> +
> + bits = iter(name.split())
> + bit = next(bits)
> + if bit == "const":
> + const = True
> + bit = next(bits)
> +
> + if bit in C_TYPE_KEYWORDS:
> + if bit == 'signed':
> + bit = ''
> + rest = list(bits)
> + if rest and rest[-1] == 'int':
> + rest = rest[:-1]
> + name = bit + ' ' + ' '.join(rest)
> + else:
> + if list(bits):
> + raise ValueError("Invalid type '%s'." % name)
> + name = bit
> +
> + ty = C_TO_RUST_TYPE_MAP[name.strip()]
> + if ptr:
> + ty = f'*{"const" if const else "mut"} {ty}'
> + return ty
> +
> class Arguments:
> """Event arguments description."""
>
> @@ -197,6 +316,43 @@ def casted(self):
> """List of argument names casted to their type."""
> return ["(%s)%s" % (type_, name) for type_, name in self._args]
>
> + def rust_decl_extern(self):
> + """Return a Rust argument list for an extern "C" function"""
> + return ", ".join((f"_{name}: {c_type_to_rust(type_)}"
> + for type_, name in self._args))
> +
> + def rust_decl(self):
> + """Return a Rust argument list for a tracepoint function"""
> + def decl_type(type_):
> + if type_ == "const char *":
> + return "&std::ffi::CStr"
> + return c_type_to_rust(type_)
> +
> + return ", ".join((f"_{name}: {decl_type(type_)}"
> + for type_, name in self._args))
> +
> + def rust_call_extern(self):
> + """Return a Rust argument list for a call to an extern "C"
> function"""
> + def rust_cast(name, type_):
> + if type_ == "const char *":
> + return f"_{name}.as_ptr()"
> + return "_{name}"
> +
> + return ", ".join((rust_cast(name, type_) for type_, name in
> self._args))
> +
> + def rust_call_varargs(self):
> + """Return a Rust argument list for a call to a C varargs function"""
> + def rust_cast(name, type_):
> + if type_ == "const char *":
> + return f"_{name}.as_ptr()"
> +
> + type_ = c_type_to_rust(type_)
> + if type_ in RUST_VARARGS_SMALL_TYPES:
> + return f"_{name} as std::ffi::c_int"
> + return f"_{name} /* as {type_} */"
> +
> + return ", ".join((rust_cast(name, type_) for type_, name in
> self._args))
> +
>
> class Event(object):
> """Event description.
> diff --git a/scripts/tracetool/format/rs.py b/scripts/tracetool/format/rs.py
> new file mode 100644
> index 00000000000..bc8b2be5971
> --- /dev/null
> +++ b/scripts/tracetool/format/rs.py
> @@ -0,0 +1,76 @@
> +# -*- coding: utf-8 -*-
This was probably copied verbatim from other tracetool files, but IIUC
it's not needed, utf-8 is the default encoding if there's no `coding`
declaration.
Also, missing SPDX header as a new file
> +
> +"""
> +trace-DIR.rs
(what's "trace-DIR"?)
> +"""
> +
> +__author__ = "Tanish Desai <tanishdesa...@gmail.com>"
> +__copyright__ = "Copyright 2025, Tanish Desai <tanishdesa...@gmail.com>"
> +__license__ = "GPL version 2 or (at your option) any later version"
> +
> +__maintainer__ = "Stefan Hajnoczi"
> +__email__ = "stefa...@redhat.com"
> +
> +
> +from tracetool import out
> +
> +
> +def generate(events, backend, group):
> + out('// This file is autogenerated by tracetool, do not edit.',
Let's use `@generated comments` https://generated.at/
> + '',
> + '#[allow(unused_imports)]',
> + 'use std::ffi::c_char;',
> + '#[allow(unused_imports)]',
> + 'use qemu_api::bindings;',
> + '',
> + '#[inline(always)]',
> + 'fn trace_event_get_state_dynamic_by_id(_id: u16) -> bool {',
> + ' unsafe { (trace_events_enabled_count != 0) && (_id != 0) }',
> + '}',
> + '',
> + 'extern "C" {',
> + ' static mut trace_events_enabled_count: u32;',
> + '}',)
> +
> + out('extern "C" {')
> +
> + for e in events:
> + out(' static mut %s: u16;' % e.api(e.QEMU_DSTATE))
> + out('}')
> +
> + # static state
> + for e in events:
> + if 'disable' in e.properties:
> + enabled = "false"
> + else:
> + enabled = "true"
> + if "tcg-exec" in e.properties:
> + # a single define for the two "sub-events"
> + out('const _TRACE_%(name)s_ENABLED: bool = %(enabled)s;',
> + name=e.original.name.upper(),
What's the difference between e.original.name and e.name?
> + enabled=enabled)
> + out('const _TRACE_%s_ENABLED: bool = %s;' % (e.name.upper(),
> enabled))
> +
> + backend.generate_begin(events, group)
> +
> + for e in events:
> + out('',
> + '#[inline(always)]',
> + '#[allow(dead_code)]',
> + 'pub fn %(api)s(%(args)s)',
> + '{',
> + api=e.api(e.QEMU_TRACE),
> + args=e.args.rust_decl())
> +
> + if "disable" not in e.properties:
> + backend.generate(e, group, check_trace_event_get_state=False)
> + if backend.check_trace_event_get_state:
> + event_id = 'TRACE_' + e.name.upper()
> + out(' if trace_event_get_state_dynamic_by_id(unsafe {
> _%(event_id)s_DSTATE}) {',
> + event_id = event_id,
> + api=e.api())
> + backend.generate(e, group, check_trace_event_get_state=True)
> + out(' }')
> + out('}')
> +
> + backend.generate_end(events, group)
> --
> 2.50.1
>
>
--
Manos Pitsidianakis
Emulation and Virtualization Engineer at Linaro Ltd
