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

diff --git a/rust/qemu-api-macros/src/bits.rs b/rust/qemu-api-macros/src/bits.rs
deleted file mode 100644
index a80a3b9fee..0000000000
--- a/rust/qemu-api-macros/src/bits.rs
+++ /dev/null
@@ -1,213 +0,0 @@
-// SPDX-License-Identifier: MIT or Apache-2.0 or GPL-2.0-or-later
-
-// shadowing is useful together with "if let"
-#![allow(clippy::shadow_unrelated)]
-
-use proc_macro2::{
-    Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree, TokenTree as TT,
-};
-use syn::Error;
-
-pub struct BitsConstInternal {
-    typ: TokenTree,
-}
-
-fn paren(ts: TokenStream) -> TokenTree {
-    TT::Group(Group::new(Delimiter::Parenthesis, ts))
-}
-
-fn ident(s: &'static str) -> TokenTree {
-    TT::Ident(Ident::new(s, Span::call_site()))
-}
-
-fn punct(ch: char) -> TokenTree {
-    TT::Punct(Punct::new(ch, Spacing::Alone))
-}
-
-/// Implements a recursive-descent parser that translates Boolean expressions on
-/// bitmasks to invocations of `const` functions defined by the `bits!` macro.
-impl BitsConstInternal {
-    // primary ::= '(' or ')'
-    //           | ident
-    //           | '!' ident
-    fn parse_primary(
-        &self,
-        tok: TokenTree,
-        it: &mut dyn Iterator<Item = TokenTree>,
-        out: &mut TokenStream,
-    ) -> Result<Option<TokenTree>, Error> {
-        let next = match tok {
-            TT::Group(ref g) => {
-                if g.delimiter() != Delimiter::Parenthesis && g.delimiter() != Delimiter::None {
-                    return Err(Error::new(g.span(), "expected parenthesis"));
-                }
-                let mut stream = g.stream().into_iter();
-                let Some(first_tok) = stream.next() else {
-                    return Err(Error::new(g.span(), "expected operand, found ')'"));
-                };
-                let mut output = TokenStream::new();
-                // start from the lowest precedence
-                let next = self.parse_or(first_tok, &mut stream, &mut output)?;
-                if let Some(tok) = next {
-                    return Err(Error::new(tok.span(), format!("unexpected token {tok}")));
-                }
-                out.extend(Some(paren(output)));
-                it.next()
-            }
-            TT::Ident(_) => {
-                let mut output = TokenStream::new();
-                output.extend([
-                    self.typ.clone(),
-                    TT::Punct(Punct::new(':', Spacing::Joint)),
-                    TT::Punct(Punct::new(':', Spacing::Joint)),
-                    tok,
-                ]);
-                out.extend(Some(paren(output)));
-                it.next()
-            }
-            TT::Punct(ref p) => {
-                if p.as_char() != '!' {
-                    return Err(Error::new(p.span(), "expected operand"));
-                }
-                let Some(rhs_tok) = it.next() else {
-                    return Err(Error::new(p.span(), "expected operand at end of input"));
-                };
-                let next = self.parse_primary(rhs_tok, it, out)?;
-                out.extend([punct('.'), ident("invert"), paren(TokenStream::new())]);
-                next
-            }
-            _ => {
-                return Err(Error::new(tok.span(), "unexpected literal"));
-            }
-        };
-        Ok(next)
-    }
-
-    fn parse_binop<
-        F: Fn(
-            &Self,
-            TokenTree,
-            &mut dyn Iterator<Item = TokenTree>,
-            &mut TokenStream,
-        ) -> Result<Option<TokenTree>, Error>,
-    >(
-        &self,
-        tok: TokenTree,
-        it: &mut dyn Iterator<Item = TokenTree>,
-        out: &mut TokenStream,
-        ch: char,
-        f: F,
-        method: &'static str,
-    ) -> Result<Option<TokenTree>, Error> {
-        let mut next = f(self, tok, it, out)?;
-        while next.is_some() {
-            let op = next.as_ref().unwrap();
-            let TT::Punct(ref p) = op else { break };
-            if p.as_char() != ch {
-                break;
-            }
-
-            let Some(rhs_tok) = it.next() else {
-                return Err(Error::new(p.span(), "expected operand at end of input"));
-            };
-            let mut rhs = TokenStream::new();
-            next = f(self, rhs_tok, it, &mut rhs)?;
-            out.extend([punct('.'), ident(method), paren(rhs)]);
-        }
-        Ok(next)
-    }
-
-    // sub ::= primary ('-' primary)*
-    pub fn parse_sub(
-        &self,
-        tok: TokenTree,
-        it: &mut dyn Iterator<Item = TokenTree>,
-        out: &mut TokenStream,
-    ) -> Result<Option<TokenTree>, Error> {
-        self.parse_binop(tok, it, out, '-', Self::parse_primary, "difference")
-    }
-
-    // and ::= sub ('&' sub)*
-    fn parse_and(
-        &self,
-        tok: TokenTree,
-        it: &mut dyn Iterator<Item = TokenTree>,
-        out: &mut TokenStream,
-    ) -> Result<Option<TokenTree>, Error> {
-        self.parse_binop(tok, it, out, '&', Self::parse_sub, "intersection")
-    }
-
-    // xor ::= and ('&' and)*
-    fn parse_xor(
-        &self,
-        tok: TokenTree,
-        it: &mut dyn Iterator<Item = TokenTree>,
-        out: &mut TokenStream,
-    ) -> Result<Option<TokenTree>, Error> {
-        self.parse_binop(tok, it, out, '^', Self::parse_and, "symmetric_difference")
-    }
-
-    // or ::= xor ('|' xor)*
-    pub fn parse_or(
-        &self,
-        tok: TokenTree,
-        it: &mut dyn Iterator<Item = TokenTree>,
-        out: &mut TokenStream,
-    ) -> Result<Option<TokenTree>, Error> {
-        self.parse_binop(tok, it, out, '|', Self::parse_xor, "union")
-    }
-
-    pub fn parse(
-        it: &mut dyn Iterator<Item = TokenTree>,
-    ) -> Result<proc_macro2::TokenStream, Error> {
-        let mut pos = Span::call_site();
-        let mut typ = proc_macro2::TokenStream::new();
-
-        // Gobble everything up to an `@` sign, which is followed by a
-        // parenthesized expression; that is, all token trees except the
-        // last two form the type.
-        let next = loop {
-            let tok = it.next();
-            if let Some(ref t) = tok {
-                pos = t.span();
-            }
-            match tok {
-                None => break None,
-                Some(TT::Punct(ref p)) if p.as_char() == '@' => {
-                    let tok = it.next();
-                    if let Some(ref t) = tok {
-                        pos = t.span();
-                    }
-                    break tok;
-                }
-                Some(x) => typ.extend(Some(x)),
-            }
-        };
-
-        let Some(tok) = next else {
-            return Err(Error::new(
-                pos,
-                "expected expression, do not call this macro directly",
-            ));
-        };
-        let TT::Group(ref _group) = tok else {
-            return Err(Error::new(
-                tok.span(),
-                "expected parenthesis, do not call this macro directly",
-            ));
-        };
-        let mut out = TokenStream::new();
-        let state = Self {
-            typ: TT::Group(Group::new(Delimiter::None, typ)),
-        };
-
-        let next = state.parse_primary(tok, it, &mut out)?;
-
-        // A parenthesized expression is a single production of the grammar,
-        // so the input must have reached the last token.
-        if let Some(tok) = next {
-            return Err(Error::new(tok.span(), format!("unexpected token {tok}")));
-        }
-        Ok(out)
-    }
-}