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

diff --git a/rust/qemu-api/tests/vmstate_tests.rs b/rust/qemu-api/tests/vmstate_tests.rs
deleted file mode 100644
index bded836eb6..0000000000
--- a/rust/qemu-api/tests/vmstate_tests.rs
+++ /dev/null
@@ -1,505 +0,0 @@
-// Copyright (C) 2025 Intel Corporation.
-// Author(s): Zhao Liu <zhao1.liu@intel.com>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-use std::{
-    ffi::{c_void, CStr},
-    mem::size_of,
-    ptr::NonNull,
-    slice,
-};
-
-use qemu_api::{
-    bindings::{
-        vmstate_info_bool, vmstate_info_int32, vmstate_info_int64, vmstate_info_int8,
-        vmstate_info_uint64, vmstate_info_uint8, vmstate_info_unused_buffer, VMStateFlags,
-    },
-    cell::{BqlCell, Opaque},
-    impl_vmstate_forward,
-    vmstate::{VMStateDescription, VMStateField},
-    vmstate_fields, vmstate_of, vmstate_struct, vmstate_unused, vmstate_validate,
-    zeroable::Zeroable,
-};
-
-const FOO_ARRAY_MAX: usize = 3;
-
-// =========================== Test VMSTATE_FOOA ===========================
-// Test the use cases of the vmstate macro, corresponding to the following C
-// macro variants:
-//   * VMSTATE_FOOA:
-//     - VMSTATE_U16
-//     - VMSTATE_UNUSED
-//     - VMSTATE_VARRAY_UINT16_UNSAFE
-//     - VMSTATE_VARRAY_MULTIPLY
-#[repr(C)]
-#[derive(Default)]
-struct FooA {
-    arr: [u8; FOO_ARRAY_MAX],
-    num: u16,
-    arr_mul: [i8; FOO_ARRAY_MAX],
-    num_mul: u32,
-    elem: i8,
-}
-
-static VMSTATE_FOOA: VMStateDescription = VMStateDescription {
-    name: c"foo_a".as_ptr(),
-    version_id: 1,
-    minimum_version_id: 1,
-    fields: vmstate_fields! {
-        vmstate_of!(FooA, elem),
-        vmstate_unused!(size_of::<i64>()),
-        vmstate_of!(FooA, arr[0 .. num]).with_version_id(0),
-        vmstate_of!(FooA, arr_mul[0 .. num_mul * 16]),
-    },
-    ..Zeroable::ZERO
-};
-
-#[test]
-fn test_vmstate_uint16() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOA.fields, 5) };
-
-    // 1st VMStateField ("elem") in VMSTATE_FOOA (corresponding to VMSTATE_UINT16)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[0].name) }.to_bytes_with_nul(),
-        b"elem\0"
-    );
-    assert_eq!(foo_fields[0].offset, 16);
-    assert_eq!(foo_fields[0].num_offset, 0);
-    assert_eq!(foo_fields[0].info, unsafe { &vmstate_info_int8 });
-    assert_eq!(foo_fields[0].version_id, 0);
-    assert_eq!(foo_fields[0].size, 1);
-    assert_eq!(foo_fields[0].num, 0);
-    assert_eq!(foo_fields[0].flags, VMStateFlags::VMS_SINGLE);
-    assert!(foo_fields[0].vmsd.is_null());
-    assert!(foo_fields[0].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_unused() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOA.fields, 5) };
-
-    // 2nd VMStateField ("unused") in VMSTATE_FOOA (corresponding to VMSTATE_UNUSED)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[1].name) }.to_bytes_with_nul(),
-        b"unused\0"
-    );
-    assert_eq!(foo_fields[1].offset, 0);
-    assert_eq!(foo_fields[1].num_offset, 0);
-    assert_eq!(foo_fields[1].info, unsafe { &vmstate_info_unused_buffer });
-    assert_eq!(foo_fields[1].version_id, 0);
-    assert_eq!(foo_fields[1].size, 8);
-    assert_eq!(foo_fields[1].num, 0);
-    assert_eq!(foo_fields[1].flags, VMStateFlags::VMS_BUFFER);
-    assert!(foo_fields[1].vmsd.is_null());
-    assert!(foo_fields[1].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_varray_uint16_unsafe() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOA.fields, 5) };
-
-    // 3rd VMStateField ("arr") in VMSTATE_FOOA (corresponding to
-    // VMSTATE_VARRAY_UINT16_UNSAFE)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[2].name) }.to_bytes_with_nul(),
-        b"arr\0"
-    );
-    assert_eq!(foo_fields[2].offset, 0);
-    assert_eq!(foo_fields[2].num_offset, 4);
-    assert_eq!(foo_fields[2].info, unsafe { &vmstate_info_uint8 });
-    assert_eq!(foo_fields[2].version_id, 0);
-    assert_eq!(foo_fields[2].size, 1);
-    assert_eq!(foo_fields[2].num, 0);
-    assert_eq!(foo_fields[2].flags, VMStateFlags::VMS_VARRAY_UINT16);
-    assert!(foo_fields[2].vmsd.is_null());
-    assert!(foo_fields[2].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_varray_multiply() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOA.fields, 5) };
-
-    // 4th VMStateField ("arr_mul") in VMSTATE_FOOA (corresponding to
-    // VMSTATE_VARRAY_MULTIPLY)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[3].name) }.to_bytes_with_nul(),
-        b"arr_mul\0"
-    );
-    assert_eq!(foo_fields[3].offset, 6);
-    assert_eq!(foo_fields[3].num_offset, 12);
-    assert_eq!(foo_fields[3].info, unsafe { &vmstate_info_int8 });
-    assert_eq!(foo_fields[3].version_id, 0);
-    assert_eq!(foo_fields[3].size, 1);
-    assert_eq!(foo_fields[3].num, 16);
-    assert_eq!(
-        foo_fields[3].flags.0,
-        VMStateFlags::VMS_VARRAY_UINT32.0 | VMStateFlags::VMS_MULTIPLY_ELEMENTS.0
-    );
-    assert!(foo_fields[3].vmsd.is_null());
-    assert!(foo_fields[3].field_exists.is_none());
-
-    // The last VMStateField in VMSTATE_FOOA.
-    assert_eq!(foo_fields[4].flags, VMStateFlags::VMS_END);
-}
-
-// =========================== Test VMSTATE_FOOB ===========================
-// Test the use cases of the vmstate macro, corresponding to the following C
-// macro variants:
-//   * VMSTATE_FOOB:
-//     - VMSTATE_BOOL_V
-//     - VMSTATE_U64
-//     - VMSTATE_STRUCT_VARRAY_UINT8
-//     - (no C version) MULTIPLY variant of VMSTATE_STRUCT_VARRAY_UINT32
-//     - VMSTATE_ARRAY
-//     - VMSTATE_STRUCT_VARRAY_UINT8 with BqlCell wrapper & test_fn
-#[repr(C)]
-#[derive(Default)]
-struct FooB {
-    arr_a: [FooA; FOO_ARRAY_MAX],
-    num_a: u8,
-    arr_a_mul: [FooA; FOO_ARRAY_MAX],
-    num_a_mul: u32,
-    wrap: BqlCell<u64>,
-    val: bool,
-    // FIXME: Use Timer array. Now we can't since it's hard to link savevm.c to test.
-    arr_i64: [i64; FOO_ARRAY_MAX],
-    arr_a_wrap: [FooA; FOO_ARRAY_MAX],
-    num_a_wrap: BqlCell<u32>,
-}
-
-fn validate_foob(_state: &FooB, _version_id: u8) -> bool {
-    true
-}
-
-static VMSTATE_FOOB: VMStateDescription = VMStateDescription {
-    name: c"foo_b".as_ptr(),
-    version_id: 2,
-    minimum_version_id: 1,
-    fields: vmstate_fields! {
-        vmstate_of!(FooB, val).with_version_id(2),
-        vmstate_of!(FooB, wrap),
-        vmstate_struct!(FooB, arr_a[0 .. num_a], &VMSTATE_FOOA, FooA).with_version_id(1),
-        vmstate_struct!(FooB, arr_a_mul[0 .. num_a_mul * 32], &VMSTATE_FOOA, FooA).with_version_id(2),
-        vmstate_of!(FooB, arr_i64),
-        vmstate_struct!(FooB, arr_a_wrap[0 .. num_a_wrap], &VMSTATE_FOOA, FooA, validate_foob),
-    },
-    ..Zeroable::ZERO
-};
-
-#[test]
-fn test_vmstate_bool_v() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOB.fields, 7) };
-
-    // 1st VMStateField ("val") in VMSTATE_FOOB (corresponding to VMSTATE_BOOL_V)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[0].name) }.to_bytes_with_nul(),
-        b"val\0"
-    );
-    assert_eq!(foo_fields[0].offset, 136);
-    assert_eq!(foo_fields[0].num_offset, 0);
-    assert_eq!(foo_fields[0].info, unsafe { &vmstate_info_bool });
-    assert_eq!(foo_fields[0].version_id, 2);
-    assert_eq!(foo_fields[0].size, 1);
-    assert_eq!(foo_fields[0].num, 0);
-    assert_eq!(foo_fields[0].flags, VMStateFlags::VMS_SINGLE);
-    assert!(foo_fields[0].vmsd.is_null());
-    assert!(foo_fields[0].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_uint64() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOB.fields, 7) };
-
-    // 2nd VMStateField ("wrap") in VMSTATE_FOOB (corresponding to VMSTATE_U64)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[1].name) }.to_bytes_with_nul(),
-        b"wrap\0"
-    );
-    assert_eq!(foo_fields[1].offset, 128);
-    assert_eq!(foo_fields[1].num_offset, 0);
-    assert_eq!(foo_fields[1].info, unsafe { &vmstate_info_uint64 });
-    assert_eq!(foo_fields[1].version_id, 0);
-    assert_eq!(foo_fields[1].size, 8);
-    assert_eq!(foo_fields[1].num, 0);
-    assert_eq!(foo_fields[1].flags, VMStateFlags::VMS_SINGLE);
-    assert!(foo_fields[1].vmsd.is_null());
-    assert!(foo_fields[1].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_struct_varray_uint8() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOB.fields, 7) };
-
-    // 3rd VMStateField ("arr_a") in VMSTATE_FOOB (corresponding to
-    // VMSTATE_STRUCT_VARRAY_UINT8)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[2].name) }.to_bytes_with_nul(),
-        b"arr_a\0"
-    );
-    assert_eq!(foo_fields[2].offset, 0);
-    assert_eq!(foo_fields[2].num_offset, 60);
-    assert!(foo_fields[2].info.is_null()); // VMSTATE_STRUCT_VARRAY_UINT8 doesn't set info field.
-    assert_eq!(foo_fields[2].version_id, 1);
-    assert_eq!(foo_fields[2].size, 20);
-    assert_eq!(foo_fields[2].num, 0);
-    assert_eq!(
-        foo_fields[2].flags.0,
-        VMStateFlags::VMS_STRUCT.0 | VMStateFlags::VMS_VARRAY_UINT8.0
-    );
-    assert_eq!(foo_fields[2].vmsd, &VMSTATE_FOOA);
-    assert!(foo_fields[2].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_struct_varray_uint32_multiply() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOB.fields, 7) };
-
-    // 4th VMStateField ("arr_a_mul") in VMSTATE_FOOB (corresponding to
-    // (no C version) MULTIPLY variant of VMSTATE_STRUCT_VARRAY_UINT32)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[3].name) }.to_bytes_with_nul(),
-        b"arr_a_mul\0"
-    );
-    assert_eq!(foo_fields[3].offset, 64);
-    assert_eq!(foo_fields[3].num_offset, 124);
-    assert!(foo_fields[3].info.is_null()); // VMSTATE_STRUCT_VARRAY_UINT8 doesn't set info field.
-    assert_eq!(foo_fields[3].version_id, 2);
-    assert_eq!(foo_fields[3].size, 20);
-    assert_eq!(foo_fields[3].num, 32);
-    assert_eq!(
-        foo_fields[3].flags.0,
-        VMStateFlags::VMS_STRUCT.0
-            | VMStateFlags::VMS_VARRAY_UINT32.0
-            | VMStateFlags::VMS_MULTIPLY_ELEMENTS.0
-    );
-    assert_eq!(foo_fields[3].vmsd, &VMSTATE_FOOA);
-    assert!(foo_fields[3].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_macro_array() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOB.fields, 7) };
-
-    // 5th VMStateField ("arr_i64") in VMSTATE_FOOB (corresponding to
-    // VMSTATE_ARRAY)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[4].name) }.to_bytes_with_nul(),
-        b"arr_i64\0"
-    );
-    assert_eq!(foo_fields[4].offset, 144);
-    assert_eq!(foo_fields[4].num_offset, 0);
-    assert_eq!(foo_fields[4].info, unsafe { &vmstate_info_int64 });
-    assert_eq!(foo_fields[4].version_id, 0);
-    assert_eq!(foo_fields[4].size, 8);
-    assert_eq!(foo_fields[4].num, FOO_ARRAY_MAX as i32);
-    assert_eq!(foo_fields[4].flags, VMStateFlags::VMS_ARRAY);
-    assert!(foo_fields[4].vmsd.is_null());
-    assert!(foo_fields[4].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_struct_varray_uint8_wrapper() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOB.fields, 7) };
-    let mut foo_b: FooB = Default::default();
-    let foo_b_p = std::ptr::addr_of_mut!(foo_b).cast::<c_void>();
-
-    // 6th VMStateField ("arr_a_wrap") in VMSTATE_FOOB (corresponding to
-    // VMSTATE_STRUCT_VARRAY_UINT8). Other fields are checked in
-    // test_vmstate_struct_varray_uint8.
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[5].name) }.to_bytes_with_nul(),
-        b"arr_a_wrap\0"
-    );
-    assert_eq!(foo_fields[5].num_offset, 228);
-    assert!(unsafe { foo_fields[5].field_exists.unwrap()(foo_b_p, 0) });
-
-    // The last VMStateField in VMSTATE_FOOB.
-    assert_eq!(foo_fields[6].flags, VMStateFlags::VMS_END);
-}
-
-// =========================== Test VMSTATE_FOOC ===========================
-// Test the use cases of the vmstate macro, corresponding to the following C
-// macro variants:
-//   * VMSTATE_FOOC:
-//     - VMSTATE_POINTER
-//     - VMSTATE_ARRAY_OF_POINTER
-struct FooCWrapper([Opaque<*mut u8>; FOO_ARRAY_MAX]); // Though Opaque<> array is almost impossible.
-
-impl_vmstate_forward!(FooCWrapper);
-
-#[repr(C)]
-struct FooC {
-    ptr: *const i32,
-    ptr_a: NonNull<FooA>,
-    arr_ptr: [Box<u8>; FOO_ARRAY_MAX],
-    arr_ptr_wrap: FooCWrapper,
-}
-
-static VMSTATE_FOOC: VMStateDescription = VMStateDescription {
-    name: c"foo_c".as_ptr(),
-    version_id: 3,
-    minimum_version_id: 1,
-    fields: vmstate_fields! {
-        vmstate_of!(FooC, ptr).with_version_id(2),
-        // FIXME: Currently vmstate_struct doesn't support the pointer to structure.
-        // VMSTATE_STRUCT_POINTER: vmstate_struct!(FooC, ptr_a, VMSTATE_FOOA, NonNull<FooA>)
-        vmstate_unused!(size_of::<NonNull<FooA>>()),
-        vmstate_of!(FooC, arr_ptr),
-        vmstate_of!(FooC, arr_ptr_wrap),
-    },
-    ..Zeroable::ZERO
-};
-
-const PTR_SIZE: usize = size_of::<*mut ()>();
-
-#[test]
-fn test_vmstate_pointer() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOC.fields, 6) };
-
-    // 1st VMStateField ("ptr") in VMSTATE_FOOC (corresponding to VMSTATE_POINTER)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[0].name) }.to_bytes_with_nul(),
-        b"ptr\0"
-    );
-    assert_eq!(foo_fields[0].offset, 0);
-    assert_eq!(foo_fields[0].num_offset, 0);
-    assert_eq!(foo_fields[0].info, unsafe { &vmstate_info_int32 });
-    assert_eq!(foo_fields[0].version_id, 2);
-    assert_eq!(foo_fields[0].size, 4);
-    assert_eq!(foo_fields[0].num, 0);
-    assert_eq!(
-        foo_fields[0].flags.0,
-        VMStateFlags::VMS_SINGLE.0 | VMStateFlags::VMS_POINTER.0
-    );
-    assert!(foo_fields[0].vmsd.is_null());
-    assert!(foo_fields[0].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_macro_array_of_pointer() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOC.fields, 6) };
-
-    // 3rd VMStateField ("arr_ptr") in VMSTATE_FOOC (corresponding to
-    // VMSTATE_ARRAY_OF_POINTER)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[2].name) }.to_bytes_with_nul(),
-        b"arr_ptr\0"
-    );
-    assert_eq!(foo_fields[2].offset, 2 * PTR_SIZE);
-    assert_eq!(foo_fields[2].num_offset, 0);
-    assert_eq!(foo_fields[2].info, unsafe { &vmstate_info_uint8 });
-    assert_eq!(foo_fields[2].version_id, 0);
-    assert_eq!(foo_fields[2].size, PTR_SIZE);
-    assert_eq!(foo_fields[2].num, FOO_ARRAY_MAX as i32);
-    assert_eq!(
-        foo_fields[2].flags.0,
-        VMStateFlags::VMS_ARRAY.0 | VMStateFlags::VMS_ARRAY_OF_POINTER.0
-    );
-    assert!(foo_fields[2].vmsd.is_null());
-    assert!(foo_fields[2].field_exists.is_none());
-}
-
-#[test]
-fn test_vmstate_macro_array_of_pointer_wrapped() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOC.fields, 6) };
-
-    // 4th VMStateField ("arr_ptr_wrap") in VMSTATE_FOOC (corresponding to
-    // VMSTATE_ARRAY_OF_POINTER)
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[3].name) }.to_bytes_with_nul(),
-        b"arr_ptr_wrap\0"
-    );
-    assert_eq!(foo_fields[3].offset, (FOO_ARRAY_MAX + 2) * PTR_SIZE);
-    assert_eq!(foo_fields[3].num_offset, 0);
-    assert_eq!(foo_fields[3].info, unsafe { &vmstate_info_uint8 });
-    assert_eq!(foo_fields[3].version_id, 0);
-    assert_eq!(foo_fields[3].size, PTR_SIZE);
-    assert_eq!(foo_fields[3].num, FOO_ARRAY_MAX as i32);
-    assert_eq!(
-        foo_fields[3].flags.0,
-        VMStateFlags::VMS_ARRAY.0 | VMStateFlags::VMS_ARRAY_OF_POINTER.0
-    );
-    assert!(foo_fields[3].vmsd.is_null());
-    assert!(foo_fields[3].field_exists.is_none());
-
-    // The last VMStateField in VMSTATE_FOOC.
-    assert_eq!(foo_fields[4].flags, VMStateFlags::VMS_END);
-}
-
-// =========================== Test VMSTATE_FOOD ===========================
-// Test the use cases of the vmstate macro, corresponding to the following C
-// macro variants:
-//   * VMSTATE_FOOD:
-//     - VMSTATE_VALIDATE
-
-// Add more member fields when vmstate_of/vmstate_struct support "test"
-// parameter.
-struct FooD;
-
-impl FooD {
-    fn validate_food_0(&self, _version_id: u8) -> bool {
-        true
-    }
-
-    fn validate_food_1(_state: &FooD, _version_id: u8) -> bool {
-        false
-    }
-}
-
-fn validate_food_2(_state: &FooD, _version_id: u8) -> bool {
-    true
-}
-
-static VMSTATE_FOOD: VMStateDescription = VMStateDescription {
-    name: c"foo_d".as_ptr(),
-    version_id: 3,
-    minimum_version_id: 1,
-    fields: vmstate_fields! {
-        vmstate_validate!(FooD, c"foo_d_0", FooD::validate_food_0),
-        vmstate_validate!(FooD, c"foo_d_1", FooD::validate_food_1),
-        vmstate_validate!(FooD, c"foo_d_2", validate_food_2),
-    },
-    ..Zeroable::ZERO
-};
-
-#[test]
-fn test_vmstate_validate() {
-    let foo_fields: &[VMStateField] = unsafe { slice::from_raw_parts(VMSTATE_FOOD.fields, 4) };
-    let mut foo_d = FooD;
-    let foo_d_p = std::ptr::addr_of_mut!(foo_d).cast::<c_void>();
-
-    // 1st VMStateField in VMSTATE_FOOD
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[0].name) }.to_bytes_with_nul(),
-        b"foo_d_0\0"
-    );
-    assert_eq!(foo_fields[0].offset, 0);
-    assert_eq!(foo_fields[0].num_offset, 0);
-    assert!(foo_fields[0].info.is_null());
-    assert_eq!(foo_fields[0].version_id, 0);
-    assert_eq!(foo_fields[0].size, 0);
-    assert_eq!(foo_fields[0].num, 0);
-    assert_eq!(
-        foo_fields[0].flags.0,
-        VMStateFlags::VMS_ARRAY.0 | VMStateFlags::VMS_MUST_EXIST.0
-    );
-    assert!(foo_fields[0].vmsd.is_null());
-    assert!(unsafe { foo_fields[0].field_exists.unwrap()(foo_d_p, 0) });
-
-    // 2nd VMStateField in VMSTATE_FOOD
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[1].name) }.to_bytes_with_nul(),
-        b"foo_d_1\0"
-    );
-    assert!(!unsafe { foo_fields[1].field_exists.unwrap()(foo_d_p, 1) });
-
-    // 3rd VMStateField in VMSTATE_FOOD
-    assert_eq!(
-        unsafe { CStr::from_ptr(foo_fields[2].name) }.to_bytes_with_nul(),
-        b"foo_d_2\0"
-    );
-    assert!(unsafe { foo_fields[2].field_exists.unwrap()(foo_d_p, 2) });
-
-    // The last VMStateField in VMSTATE_FOOD.
-    assert_eq!(foo_fields[3].flags, VMStateFlags::VMS_END);
-}