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=""):
+ 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 -*-
+
+"""
+trace-DIR.rs
+"""
+
+__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.',
+ '',
+ '#[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(),
+ 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
