Merge tag 'for-upstream' of https://gitlab.com/bonzini/qemu into staging

* cpu-exec: more cleanups to CPU loop exits
* python: bump bundled Meson to 1.9.0
* rust: require Rust 1.83.0
* rust: temporarily remove from Ubuntu CI
* rust: vmstate: convert to use builder pattern
* rust: split "qemu-api" crate
* rust: rename qemu_api_macros -> qemu_macros
* rust: re-export qemu macros from other crates
* x86: fix functional test failure for Xen emulation
* x86: cleanups

# -----BEGIN PGP SIGNATURE-----
#
# iQFIBAABCgAyFiEE8TM4V0tmI4mGbHaCv/vSX3jHroMFAmjK6ZsUHHBib256aW5p
# QHJlZGhhdC5jb20ACgkQv/vSX3jHroNBKwf/aadInCT4vASOfpxbwZgYfYgR2m2m
# BJE9oYKxZJ6MlEOU/1Wfywf9fg4leMSh3XxkDKkEIL19yS6emwin8n3SNYrdAFn3
# 6u4IIWO4NI1Ht3NKytrqFk9wtbH9pAs/gVHLlnmpMxIqtOtZLumPAKNz8rlantmK
# UVDYL3Y0L4pD9i5FK1ObMNpk5AsWNr8Tr64fmb+nTkHutld3sBrEMCLI0+EByGyN
# lQ16sLn9PGqHOr210zuQP7wP2T3NCI3YokFSPQrUUL8LZGxRdXoNF4hI4uZDKGdn
# UbtRu9EkM052qzfsFMrEw5JSbdxEfIjKlPoFKseMv+aWvNAuximAraD3Vg==
# =Lr+x
# -----END PGP SIGNATURE-----
# gpg: Signature made Wed 17 Sep 2025 10:02:19 AM PDT
# gpg:                using RSA key F13338574B662389866C7682BFFBD25F78C7AE83
# gpg:                issuer "pbonzini@redhat.com"
# gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>" [unknown]
# gpg:                 aka "Paolo Bonzini <pbonzini@redhat.com>" [unknown]
# gpg: WARNING: The key's User ID is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 46F5 9FBD 57D6 12E7 BFD4  E2F7 7E15 100C CD36 69B1
#      Subkey fingerprint: F133 3857 4B66 2389 866C  7682 BFFB D25F 78C7 AE83

* tag 'for-upstream' of https://gitlab.com/bonzini/qemu: (60 commits)
  accel/kvm: Set guest_memfd_offset to non-zero value only when guest_memfd is valid
  accel/kvm: Zero out mem explicitly in kvm_set_user_memory_region()
  accel/kvm: Switch to check KVM_CAP_GUEST_MEMFD and KVM_CAP_USER_MEMORY2 on VM
  i386/kvm: Drop KVM_CAP_X86_SMM check in kvm_arch_init()
  multiboot: Fix the split lock
  target/i386: Define enum X86ASIdx for x86's address spaces
  i386/cpu: Enable SMM cpu address space under KVM
  hpet: guard IRQ handling with BQL
  rust: do not inline do_init_io
  rust: meson: remove unnecessary complication in device crates
  docs: update rust.rst
  rust: re-export qemu macros from common/qom/hwcore
  rust: re-export qemu_macros internal helper in "bits"
  rust: repurpose qemu_api -> tests
  rust/pl011: drop dependency on qemu_api
  rust/hpet: drop now unneeded qemu_api dep
  rust: rename qemu_api_macros -> qemu_macros
  rust: split "hwcore" crate
  rust: split "system" crate
  rust: split "chardev" crate
  ...

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>

1 files changed, 0 insertions, 149 deletions

diff --git a/rust/qemu-api/src/log.rs b/rust/qemu-api/src/log.rs
deleted file mode 100644
index a441b8c1f2..0000000000
--- a/rust/qemu-api/src/log.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 2025 Bernhard Beschow <shentey@gmail.com>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-//! Bindings for QEMU's logging infrastructure
-
-use std::{
-    io::{self, Write},
-    ptr::NonNull,
-};
-
-use crate::{bindings, errno};
-
-#[repr(u32)]
-/// Represents specific error categories within QEMU's logging system.
-///
-/// The `Log` enum provides a Rust abstraction for logging errors, corresponding
-/// to a subset of the error categories defined in the C implementation.
-pub enum Log {
-    /// Log invalid access caused by the guest.
-    /// Corresponds to `LOG_GUEST_ERROR` in the C implementation.
-    GuestError = bindings::LOG_GUEST_ERROR,
-
-    /// Log guest access of unimplemented functionality.
-    /// Corresponds to `LOG_UNIMP` in the C implementation.
-    Unimp = bindings::LOG_UNIMP,
-}
-
-/// A RAII guard for QEMU's logging infrastructure.  Creating the guard
-/// locks the log file, and dropping it (letting it go out of scope) unlocks
-/// the file.
-///
-/// As long as the guard lives, it can be written to using [`std::io::Write`].
-///
-/// The locking is recursive, therefore owning a guard does not prevent
-/// using [`log_mask_ln!()`](crate::log_mask_ln).
-pub struct LogGuard(NonNull<bindings::FILE>);
-
-impl LogGuard {
-    /// Return a RAII guard that writes to QEMU's logging infrastructure.
-    /// The log file is locked while the guard exists, ensuring that there
-    /// is no tearing of the messages.
-    ///
-    /// Return `None` if the log file is closed and could not be opened.
-    /// Do *not* use `unwrap()` on the result; failure can be handled simply
-    /// by not logging anything.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use qemu_api::log::LogGuard;
-    /// # use std::io::Write;
-    /// if let Some(mut log) = LogGuard::new() {
-    ///     writeln!(log, "test");
-    /// }
-    /// ```
-    pub fn new() -> Option<Self> {
-        let f = unsafe { bindings::qemu_log_trylock() }.cast();
-        NonNull::new(f).map(Self)
-    }
-
-    /// Writes a formatted string into the log, returning any error encountered.
-    ///
-    /// This method is primarily used by the
-    /// [`log_mask_ln!()`](crate::log_mask_ln) macro, and it is rare for it
-    /// to be called explicitly.  It is public because it is the only way to
-    /// examine the error, which `log_mask_ln!()` ignores
-    ///
-    /// Unlike `log_mask_ln!()`, it does *not* append a newline at the end.
-    pub fn log_fmt(args: std::fmt::Arguments) -> io::Result<()> {
-        if let Some(mut log) = Self::new() {
-            log.write_fmt(args)?;
-        }
-        Ok(())
-    }
-}
-
-impl Write for LogGuard {
-    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
-        let ret = unsafe {
-            bindings::rust_fwrite(bytes.as_ptr().cast(), 1, bytes.len(), self.0.as_ptr())
-        };
-        errno::into_io_result(ret)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        // Do nothing, dropping the guard takes care of flushing
-        Ok(())
-    }
-}
-
-impl Drop for LogGuard {
-    fn drop(&mut self) {
-        unsafe {
-            bindings::qemu_log_unlock(self.0.as_ptr());
-        }
-    }
-}
-
-/// A macro to log messages conditionally based on a provided mask.
-///
-/// The `log_mask_ln` macro checks whether the given mask matches the current
-/// log level and, if so, formats and logs the message. It is the Rust
-/// counterpart of the `qemu_log_mask()` macro in the C implementation.
-///
-/// Errors from writing to the log are ignored.
-///
-/// # Parameters
-///
-/// - `$mask`: A log level mask. This should be a variant of the `Log` enum.
-/// - `$fmt`: A format string following the syntax and rules of the `format!`
-///   macro. It specifies the structure of the log message.
-/// - `$args`: Optional arguments to be interpolated into the format string.
-///
-/// # Example
-///
-/// ```
-/// use qemu_api::{log::Log, log_mask_ln};
-///
-/// let error_address = 0xbad;
-/// log_mask_ln!(Log::GuestError, "Address 0x{error_address:x} out of range");
-/// ```
-///
-/// It is also possible to use printf-style formatting, as well as having a
-/// trailing `,`:
-///
-/// ```
-/// use qemu_api::{log::Log, log_mask_ln};
-///
-/// let error_address = 0xbad;
-/// log_mask_ln!(
-///     Log::GuestError,
-///     "Address 0x{:x} out of range",
-///     error_address,
-/// );
-/// ```
-#[macro_export]
-macro_rules! log_mask_ln {
-    ($mask:expr, $fmt:tt $($args:tt)*) => {{
-        // Type assertion to enforce type `Log` for $mask
-        let _: Log = $mask;
-
-        if unsafe {
-            (::qemu_api::bindings::qemu_loglevel & ($mask as std::os::raw::c_int)) != 0
-        } {
-            _ = ::qemu_api::log::LogGuard::log_fmt(
-                format_args!("{}\n", format_args!($fmt $($args)*)));
-        }
-    }};
-}