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, 204 deletions

diff --git a/rust/qemu-api/src/memory.rs b/rust/qemu-api/src/memory.rs
deleted file mode 100644
index e40fad6cf1..0000000000
--- a/rust/qemu-api/src/memory.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2024 Red Hat, Inc.
-// Author(s): Paolo Bonzini <pbonzini@redhat.com>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-//! Bindings for `MemoryRegion`, `MemoryRegionOps` and `MemTxAttrs`
-
-use std::{
-    ffi::{c_uint, c_void, CStr, CString},
-    marker::PhantomData,
-};
-
-pub use bindings::{hwaddr, MemTxAttrs};
-
-use crate::{
-    bindings::{self, device_endian, memory_region_init_io},
-    callbacks::FnCall,
-    cell::Opaque,
-    prelude::*,
-    uninit::MaybeUninitField,
-    zeroable::Zeroable,
-};
-
-pub struct MemoryRegionOps<T>(
-    bindings::MemoryRegionOps,
-    // Note: quite often you'll see PhantomData<fn(&T)> mentioned when discussing
-    // covariance and contravariance; you don't need any of those to understand
-    // this usage of PhantomData.  Quite simply, MemoryRegionOps<T> *logically*
-    // holds callbacks that take an argument of type &T, except the type is erased
-    // before the callback is stored in the bindings::MemoryRegionOps field.
-    // The argument of PhantomData is a function pointer in order to represent
-    // that relationship; while that will also provide desirable and safe variance
-    // for T, variance is not the point but just a consequence.
-    PhantomData<fn(&T)>,
-);
-
-// SAFETY: When a *const T is passed to the callbacks, the call itself
-// is done in a thread-safe manner.  The invocation is okay as long as
-// T itself is `Sync`.
-unsafe impl<T: Sync> Sync for MemoryRegionOps<T> {}
-
-#[derive(Clone)]
-pub struct MemoryRegionOpsBuilder<T>(bindings::MemoryRegionOps, PhantomData<fn(&T)>);
-
-unsafe extern "C" fn memory_region_ops_read_cb<T, F: for<'a> FnCall<(&'a T, hwaddr, u32), u64>>(
-    opaque: *mut c_void,
-    addr: hwaddr,
-    size: c_uint,
-) -> u64 {
-    F::call((unsafe { &*(opaque.cast::<T>()) }, addr, size))
-}
-
-unsafe extern "C" fn memory_region_ops_write_cb<T, F: for<'a> FnCall<(&'a T, hwaddr, u64, u32)>>(
-    opaque: *mut c_void,
-    addr: hwaddr,
-    data: u64,
-    size: c_uint,
-) {
-    F::call((unsafe { &*(opaque.cast::<T>()) }, addr, data, size))
-}
-
-impl<T> MemoryRegionOpsBuilder<T> {
-    #[must_use]
-    pub const fn read<F: for<'a> FnCall<(&'a T, hwaddr, u32), u64>>(mut self, _f: &F) -> Self {
-        self.0.read = Some(memory_region_ops_read_cb::<T, F>);
-        self
-    }
-
-    #[must_use]
-    pub const fn write<F: for<'a> FnCall<(&'a T, hwaddr, u64, u32)>>(mut self, _f: &F) -> Self {
-        self.0.write = Some(memory_region_ops_write_cb::<T, F>);
-        self
-    }
-
-    #[must_use]
-    pub const fn big_endian(mut self) -> Self {
-        self.0.endianness = device_endian::DEVICE_BIG_ENDIAN;
-        self
-    }
-
-    #[must_use]
-    pub const fn little_endian(mut self) -> Self {
-        self.0.endianness = device_endian::DEVICE_LITTLE_ENDIAN;
-        self
-    }
-
-    #[must_use]
-    pub const fn native_endian(mut self) -> Self {
-        self.0.endianness = device_endian::DEVICE_NATIVE_ENDIAN;
-        self
-    }
-
-    #[must_use]
-    pub const fn valid_sizes(mut self, min: u32, max: u32) -> Self {
-        self.0.valid.min_access_size = min;
-        self.0.valid.max_access_size = max;
-        self
-    }
-
-    #[must_use]
-    pub const fn valid_unaligned(mut self) -> Self {
-        self.0.valid.unaligned = true;
-        self
-    }
-
-    #[must_use]
-    pub const fn impl_sizes(mut self, min: u32, max: u32) -> Self {
-        self.0.impl_.min_access_size = min;
-        self.0.impl_.max_access_size = max;
-        self
-    }
-
-    #[must_use]
-    pub const fn impl_unaligned(mut self) -> Self {
-        self.0.impl_.unaligned = true;
-        self
-    }
-
-    #[must_use]
-    pub const fn build(self) -> MemoryRegionOps<T> {
-        MemoryRegionOps::<T>(self.0, PhantomData)
-    }
-
-    #[must_use]
-    pub const fn new() -> Self {
-        Self(bindings::MemoryRegionOps::ZERO, PhantomData)
-    }
-}
-
-impl<T> Default for MemoryRegionOpsBuilder<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// A safe wrapper around [`bindings::MemoryRegion`].
-#[repr(transparent)]
-#[derive(qemu_api_macros::Wrapper)]
-pub struct MemoryRegion(Opaque<bindings::MemoryRegion>);
-
-unsafe impl Send for MemoryRegion {}
-unsafe impl Sync for MemoryRegion {}
-
-impl MemoryRegion {
-    // inline to ensure that it is not included in tests, which only
-    // link to hwcore and qom.  FIXME: inlining is actually the opposite
-    // of what we want, since this is the type-erased version of the
-    // init_io function below.  Look into splitting the qemu_api crate.
-    #[inline(always)]
-    unsafe fn do_init_io(
-        slot: *mut bindings::MemoryRegion,
-        owner: *mut bindings::Object,
-        ops: &'static bindings::MemoryRegionOps,
-        name: &'static str,
-        size: u64,
-    ) {
-        unsafe {
-            let cstr = CString::new(name).unwrap();
-            memory_region_init_io(
-                slot,
-                owner,
-                ops,
-                owner.cast::<c_void>(),
-                cstr.as_ptr(),
-                size,
-            );
-        }
-    }
-
-    pub fn init_io<T: IsA<Object>>(
-        this: &mut MaybeUninitField<'_, T, Self>,
-        ops: &'static MemoryRegionOps<T>,
-        name: &'static str,
-        size: u64,
-    ) {
-        unsafe {
-            Self::do_init_io(
-                this.as_mut_ptr().cast(),
-                MaybeUninitField::parent_mut(this).cast(),
-                &ops.0,
-                name,
-                size,
-            );
-        }
-    }
-}
-
-unsafe impl ObjectType for MemoryRegion {
-    type Class = bindings::MemoryRegionClass;
-    const TYPE_NAME: &'static CStr =
-        unsafe { CStr::from_bytes_with_nul_unchecked(bindings::TYPE_MEMORY_REGION) };
-}
-qom_isa!(MemoryRegion: Object);
-
-/// A special `MemTxAttrs` constant, used to indicate that no memory
-/// attributes are specified.
-///
-/// Bus masters which don't specify any attributes will get this,
-/// which has all attribute bits clear except the topmost one
-/// (so that we can distinguish "all attributes deliberately clear"
-/// from "didn't specify" if necessary).
-pub const MEMTXATTRS_UNSPECIFIED: MemTxAttrs = MemTxAttrs {
-    unspecified: true,
-    ..Zeroable::ZERO
-};