Rust
M: Manos Pitsidianakis <manos.pitsidianakis@linaro.org>
S: Maintained
+F: rust/bql/
F: rust/common/
F: rust/migration/
F: rust/qemu-api
"qemu_api_macros",
]
+[[package]]
+name = "bql"
+version = "0.1.0"
+dependencies = [
+ "migration",
+]
+
[[package]]
name = "common"
version = "0.1.0"
name = "hpet"
version = "0.1.0"
dependencies = [
+ "bql",
"common",
"migration",
"qemu_api",
"bilge",
"bilge-impl",
"bits",
+ "bql",
"common",
"migration",
"qemu_api",
name = "qemu_api"
version = "0.1.0"
dependencies = [
+ "bql",
"common",
"migration",
"qemu_api_macros",
resolver = "2"
members = [
"bits",
+ "bql",
"common",
"migration",
"qemu-api-macros",
--- /dev/null
+[package]
+name = "bql"
+version = "0.1.0"
+description = "Rust bindings for QEMU/BQL"
+resolver = "2"
+publish = false
+
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+migration = { path = "../migration" }
+
+[features]
+default = ["debug_cell"]
+debug_cell = []
+
+[lints]
+workspace = true
--- /dev/null
+../util/build.rs
\ No newline at end of file
--- /dev/null
+_bql_cfg = run_command(rustc_args,
+ '--config-headers', config_host_h, '--features', files('Cargo.toml'),
+ capture: true, check: true).stdout().strip().splitlines()
+
+if get_option('debug_mutex')
+ _bql_cfg += ['--cfg', 'feature="debug_cell"']
+endif
+
+#
+# TODO: Remove this comment when the clang/libclang mismatch issue is solved.
+#
+# Rust bindings generation with `bindgen` might fail in some cases where the
+# detected `libclang` does not match the expected `clang` version/target. In
+# this case you must pass the path to `clang` and `libclang` to your build
+# command invocation using the environment variables CLANG_PATH and
+# LIBCLANG_PATH
+_bql_bindings_inc_rs = rust.bindgen(
+ input: 'wrapper.h',
+ dependencies: common_ss.all_dependencies(),
+ output: 'bindings.inc.rs',
+ include_directories: bindings_incdir,
+ bindgen_version: ['>=0.60.0'],
+ args: bindgen_args_common,
+)
+
+_bql_rs = static_library(
+ 'bql',
+ structured_sources(
+ [
+ 'src/lib.rs',
+ 'src/bindings.rs',
+ 'src/cell.rs',
+ ],
+ {'.': _bql_bindings_inc_rs}
+ ),
+ override_options: ['rust_std=2021', 'build.rust_std=2021'],
+ rust_abi: 'rust',
+ rust_args: _bql_cfg,
+ link_with: [_migration_rs],
+)
+
+bql_rs = declare_dependency(link_with: [_bql_rs],
+ dependencies: [qemuutil])
+
+# Doctests are essentially integration tests, so they need the same dependencies.
+# Note that running them requires the object files for C code, so place them
+# in a separate suite that is run by the "build" CI jobs rather than "check".
+rust.doctest('rust-bql-rs-doctests',
+ _bql_rs,
+ protocol: 'rust',
+ dependencies: bql_rs,
+ suite: ['doc', 'rust'])
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+#![allow(
+ dead_code,
+ improper_ctypes_definitions,
+ improper_ctypes,
+ non_camel_case_types,
+ non_snake_case,
+ non_upper_case_globals,
+ unnecessary_transmutes,
+ unsafe_op_in_unsafe_fn,
+ clippy::pedantic,
+ clippy::restriction,
+ clippy::style,
+ clippy::missing_const_for_fn,
+ clippy::ptr_offset_with_cast,
+ clippy::useless_transmute,
+ clippy::missing_safety_doc,
+ clippy::too_many_arguments
+)]
+
+#[cfg(MESON)]
+include!("bindings.inc.rs");
+
+#[cfg(not(MESON))]
+include!(concat!(env!("OUT_DIR"), "/bindings.inc.rs"));
//!
//! ### Example
//!
-//! ```
+//! ```ignore
+//! # use bql::BqlRefCell;
//! # use qemu_api::prelude::*;
-//! # use qemu_api::{cell::BqlRefCell, irq::InterruptSource, irq::IRQState};
+//! # use qemu_api::{irq::InterruptSource, irq::IRQState};
//! # use qemu_api::{sysbus::SysBusDevice, qom::Owned, qom::ParentField};
//! # const N_GPIOS: usize = 8;
//! # struct PL061Registers { /* ... */ }
//! Multiple immutable borrows are allowed via [`borrow`](BqlRefCell::borrow),
//! or a single mutable borrow via [`borrow_mut`](BqlRefCell::borrow_mut). The
//! thread will panic if these rules are violated or if the BQL is not held.
-
use std::{
cell::{Cell, UnsafeCell},
cmp::Ordering,
use migration::impl_vmstate_transparent;
-use crate::bindings;
-
-/// An internal function that is used by doctests.
-pub fn bql_start_test() {
- // SAFETY: integration tests are run with --test-threads=1, while
- // unit tests and doctests are not multithreaded and do not have
- // any BQL-protected data. Just set bql_locked to true.
- unsafe {
- bindings::rust_bql_mock_lock();
- }
-}
-
-pub fn bql_locked() -> bool {
- // SAFETY: the function does nothing but return a thread-local bool
- unsafe { bindings::bql_locked() }
-}
-
-fn bql_block_unlock(increase: bool) {
- // SAFETY: this only adjusts a counter
- unsafe {
- bindings::bql_block_unlock(increase);
- }
-}
-
/// A mutable memory location that is protected by the Big QEMU Lock.
///
/// # Memory layout
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let c = BqlCell::new(5);
/// ```
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let c = BqlCell::new(5);
///
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let cell = BqlCell::new(5);
/// assert_eq!(cell.get(), 5);
/// ```
#[inline]
pub fn replace(&self, val: T) -> T {
- assert!(bql_locked());
+ assert!(crate::is_locked());
// SAFETY: This can cause data races if called from multiple threads,
// but it won't happen as long as C code accesses the value
// under BQL protection only.
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let c = BqlCell::new(5);
/// let five = c.into_inner();
/// assert_eq!(five, 5);
/// ```
pub fn into_inner(self) -> T {
- assert!(bql_locked());
+ assert!(crate::is_locked());
self.value.into_inner()
}
}
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let c = BqlCell::new(5);
///
/// ```
#[inline]
pub fn get(&self) -> T {
- assert!(bql_locked());
+ assert!(crate::is_locked());
// SAFETY: This can cause data races if called from multiple threads,
// but it won't happen as long as C code accesses the value
// under BQL protection only.
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let c = BqlCell::new(5);
///
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlCell;
+ /// # bql::start_test();
///
/// let c = BqlCell::new(5);
/// let five = c.take();
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlRefCell;
+ /// use bql::BqlRefCell;
///
/// let c = BqlRefCell::new(5);
/// ```
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlRefCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlRefCell;
+ /// # bql::start_test();
///
/// let c = BqlRefCell::new(5);
///
/// An example of panic:
///
/// ```should_panic
- /// use qemu_api::cell::BqlRefCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlRefCell;
+ /// # bql::start_test();
///
/// let c = BqlRefCell::new(5);
///
self.borrowed_at.set(Some(std::panic::Location::caller()));
}
- bql_block_unlock(true);
+ crate::block_unlock(true);
// SAFETY: `BorrowRef` ensures that there is only immutable access
// to the value while borrowed.
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlRefCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlRefCell;
+ /// # bql::start_test();
///
/// let c = BqlRefCell::new("hello".to_owned());
///
/// An example of panic:
///
/// ```should_panic
- /// use qemu_api::cell::BqlRefCell;
- /// # qemu_api::cell::bql_start_test();
+ /// use bql::BqlRefCell;
+ /// # bql::start_test();
///
/// let c = BqlRefCell::new(5);
/// let m = c.borrow();
}
// SAFETY: this only adjusts a counter
- bql_block_unlock(true);
+ crate::block_unlock(true);
// SAFETY: `BorrowRefMut` guarantees unique access.
let value = unsafe { NonNull::new_unchecked(self.value.get()) };
/// # Examples
///
/// ```
- /// use qemu_api::cell::BqlRefCell;
+ /// use bql::BqlRefCell;
///
/// let c = BqlRefCell::new(5);
///
let borrow = self.borrow.get();
debug_assert!(is_reading(borrow));
self.borrow.set(borrow - 1);
- bql_block_unlock(false)
+ crate::block_unlock(false)
}
}
let borrow = self.borrow.get();
debug_assert!(is_writing(borrow));
self.borrow.set(borrow + 1);
- bql_block_unlock(false)
+ crate::block_unlock(false)
}
}
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+mod bindings;
+use bindings::{bql_block_unlock, bql_locked, rust_bql_mock_lock};
+
+mod cell;
+pub use cell::*;
+
+/// An internal function that is used by doctests.
+pub fn start_test() {
+ // SAFETY: integration tests are run with --test-threads=1, while
+ // unit tests and doctests are not multithreaded and do not have
+ // any BQL-protected data. Just set bql_locked to true.
+ unsafe {
+ rust_bql_mock_lock();
+ }
+}
+
+pub fn is_locked() -> bool {
+ // SAFETY: the function does nothing but return a thread-local bool
+ unsafe { bql_locked() }
+}
+
+pub fn block_unlock(increase: bool) {
+ // SAFETY: this only adjusts a counter
+ unsafe {
+ bql_block_unlock(increase);
+ }
+}
--- /dev/null
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+/*
+ * This header file is meant to be used as input to the `bindgen` application
+ * in order to generate C FFI compatible Rust bindings.
+ */
+
+#ifndef __CLANG_STDATOMIC_H
+#define __CLANG_STDATOMIC_H
+/*
+ * Fix potential missing stdatomic.h error in case bindgen does not insert the
+ * correct libclang header paths on its own. We do not use stdatomic.h symbols
+ * in QEMU code, so it's fine to declare dummy types instead.
+ */
+typedef enum memory_order {
+ memory_order_relaxed,
+ memory_order_consume,
+ memory_order_acquire,
+ memory_order_release,
+ memory_order_acq_rel,
+ memory_order_seq_cst,
+} memory_order;
+#endif /* __CLANG_STDATOMIC_H */
+
+#include "qemu/osdep.h"
+
+#include "qemu/main-loop.h"
//! and only at FFI boundaries. For QEMU-specific types that need interior
//! mutability, prefer [`BqlCell`] or [`BqlRefCell`].
//!
-//! [`BqlCell`]: ../../qemu_api/cell/struct.BqlCell.html
-//! [`BqlRefCell`]: ../../qemu_api/cell/struct.BqlRefCell.html
+//! [`BqlCell`]: ../../bql/cell/struct.BqlCell.html
+//! [`BqlRefCell`]: ../../bql/cell/struct.BqlRefCell.html
use std::{cell::UnsafeCell, fmt, marker::PhantomPinned, mem::MaybeUninit, ptr::NonNull};
/// Stores an opaque value that is shared with C code.
bits = { path = "../../../bits" }
common = { path = "../../../common" }
util = { path = "../../../util" }
+bql = { path = "../../../bql" }
migration = { path = "../../../migration" }
qemu_api = { path = "../../../qemu-api" }
qemu_api_macros = { path = "../../../qemu-api-macros" }
qemu_api_rs,
util_rs,
migration_rs,
+ bql_rs,
qemu_api_macros,
],
)
use std::{ffi::CStr, mem::size_of};
+use bql::BqlRefCell;
use common::{static_assert, uninit_field_mut};
use migration::{
self, impl_vmstate_forward, impl_vmstate_struct, vmstate_fields, vmstate_of,
common = { path = "../../../common" }
util = { path = "../../../util" }
migration = { path = "../../../migration" }
+bql = { path = "../../../bql" }
qemu_api = { path = "../../../qemu-api" }
qemu_api_macros = { path = "../../../qemu-api-macros" }
qemu_api_rs,
util_rs,
migration_rs,
+ bql_rs,
qemu_api_macros,
],
)
slice::from_ref,
};
+use bql::{BqlCell, BqlRefCell};
use common::{bitops::IntegerExt, uninit_field_mut};
use migration::{
self, impl_vmstate_struct, vmstate_fields, vmstate_of, vmstate_subsections, vmstate_validate,
address_space_memory, address_space_stl_le, qdev_prop_bit, qdev_prop_bool,
qdev_prop_uint32, qdev_prop_usize,
},
- cell::{BqlCell, BqlRefCell},
irq::InterruptSource,
memory::{
hwaddr, MemoryRegion, MemoryRegionOps, MemoryRegionOpsBuilder, MEMTXATTRS_UNSPECIFIED,
use std::ptr::addr_of_mut;
use common::Zeroable;
-use qemu_api::cell::bql_locked;
/// Each `HPETState` represents a Event Timer Block. The v1 spec supports
/// up to 8 blocks. QEMU only uses 1 block (in PC machine).
impl HPETFwConfig {
pub(crate) fn assign_hpet_id() -> Result<usize, &'static str> {
- assert!(bql_locked());
+ assert!(bql::is_locked());
// SAFETY: all accesses go through these methods, which guarantee
// that the accesses are protected by the BQL.
let mut fw_cfg = unsafe { *addr_of_mut!(hpet_fw_cfg) };
}
pub(crate) fn update_hpet_cfg(hpet_id: usize, timer_block_id: u32, address: u64) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
// SAFETY: all accesses go through these methods, which guarantee
// that the accesses are protected by the BQL.
let mut fw_cfg = unsafe { *addr_of_mut!(hpet_fw_cfg) };
subdir('bits')
subdir('util')
subdir('migration')
+subdir('bql')
subdir('qemu-api')
subdir('hw')
/// [`impl_vmstate_bitsized`](crate::impl_vmstate_bitsized), and
/// [`impl_vmstate_struct`](crate::impl_vmstate_struct) help with this.
///
-/// [`BqlCell`]: ../../qemu_api/cell/struct.BqlCell.html
-/// [`BqlRefCell`]: ../../qemu_api/cell/struct.BqlRefCell.html
+/// [`BqlCell`]: ../../bql/cell/struct.BqlCell.html
+/// [`BqlRefCell`]: ../../bql/cell/struct.BqlRefCell.html
/// [`Owned`]: ../../qemu_api/qom/struct.Owned.html
#[macro_export]
macro_rules! vmstate_of {
common = { path = "../common" }
migration = { path = "../migration" }
util = { path = "../util" }
+bql = { path = "../bql" }
qemu_api_macros = { path = "../qemu-api-macros" }
-[features]
-default = ["debug_cell"]
-debug_cell = []
-
[lints]
workspace = true
'--config-headers', config_host_h, '--features', files('Cargo.toml'),
capture: true, check: true).stdout().strip().splitlines()
-if get_option('debug_mutex')
- _qemu_api_cfg += ['--cfg', 'feature="debug_cell"']
-endif
-
c_enums = [
'DeviceCategory',
'GpioPolarity',
[
'src/lib.rs',
'src/bindings.rs',
- 'src/cell.rs',
'src/chardev.rs',
'src/irq.rs',
'src/memory.rs',
override_options: ['rust_std=2021', 'build.rust_std=2021'],
rust_abi: 'rust',
rust_args: _qemu_api_cfg,
- dependencies: [anyhow_rs, common_rs, foreign_rs, libc_rs, migration_rs, qemu_api_macros,
+ dependencies: [anyhow_rs, bql_rs, common_rs, foreign_rs, libc_rs, migration_rs, qemu_api_macros,
util_rs, qom, hwcore, chardev],
)
qemu_api_rs = declare_dependency(link_with: [_qemu_api_rs],
dependencies: [qemu_api_macros, qom, hwcore, chardev, migration])
-# Doctests are essentially integration tests, so they need the same dependencies.
-# Note that running them requires the object files for C code, so place them
-# in a separate suite that is run by the "build" CI jobs rather than "check".
-rust.doctest('rust-qemu-api-doctests',
- _qemu_api_rs,
- protocol: 'rust',
- dependencies: [qemu_api_rs],
- suite: ['doc', 'rust'])
-
test('rust-qemu-api-integration',
executable(
'rust-qemu-api-integration',
override_options: ['rust_std=2021', 'build.rust_std=2021'],
rust_args: ['--test'],
install: false,
- dependencies: [common_rs, util_rs, migration_rs, qemu_api_rs]),
+ dependencies: [bql_rs, common_rs, util_rs, migration_rs, qemu_api_rs]),
args: [
'--test', '--test-threads', '1',
'--format', 'pretty',
slice,
};
+use bql::{BqlRefCell, BqlRefMut};
use common::{callbacks::FnCall, errno, Opaque};
-use crate::{
- bindings,
- cell::{BqlRefCell, BqlRefMut},
- prelude::*,
-};
+use crate::{bindings, prelude::*};
/// A safe wrapper around [`bindings::Chardev`].
#[repr(transparent)]
_pin: PhantomPinned,
}
-impl Write for BqlRefMut<'_, bindings::CharBackend> {
+pub struct CharBackendMut<'a>(BqlRefMut<'a, bindings::CharBackend>);
+
+impl Write for CharBackendMut<'_> {
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- let chr: &mut bindings::CharBackend = self;
+ let chr: &mut bindings::CharBackend = &mut self.0;
let len = buf.len().try_into().unwrap();
let r = unsafe { bindings::qemu_chr_fe_write(addr_of_mut!(*chr), buf.as_ptr(), len) };
}
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
- let chr: &mut bindings::CharBackend = self;
+ let chr: &mut bindings::CharBackend = &mut self.0;
let len = buf.len().try_into().unwrap();
let r = unsafe { bindings::qemu_chr_fe_write_all(addr_of_mut!(*chr), buf.as_ptr(), len) };
/// the big QEMU lock while the character device is borrowed, as
/// that might cause C code to write to the character device.
pub fn borrow_mut(&self) -> impl Write + '_ {
- self.inner.borrow_mut()
+ CharBackendMut(self.inner.borrow_mut())
}
/// Send a continuous stream of zero bits on the line if `enabled` is
ptr,
};
+use bql::BqlCell;
use common::Opaque;
use crate::{
#[rustfmt::skip]
pub mod prelude;
-pub mod cell;
pub mod chardev;
pub mod irq;
pub mod memory;
//! Commonly used traits and types for QEMU.
-pub use crate::cell::BqlCell;
-pub use crate::cell::BqlRefCell;
-
pub use crate::qdev::DeviceMethods;
pub use crate::qom::InterfaceType;
use crate::{
bindings::{self, qdev_init_gpio_in, qdev_init_gpio_out, ResettableClass},
- cell::bql_locked,
chardev::Chardev,
irq::InterruptSource,
prelude::*,
cb: Option<unsafe extern "C" fn(*mut c_void, ClockEvent)>,
events: ClockEvent,
) -> Owned<Clock> {
- assert!(bql_locked());
+ assert!(bql::is_locked());
// SAFETY: the clock is heap allocated, but qdev_init_clock_in()
// does not gift the reference to its caller; so use Owned::from to
Self::Target: IsA<DeviceState>,
{
fn prop_set_chr(&self, propname: &str, chr: &Owned<Chardev>) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
let c_propname = CString::new(propname).unwrap();
let chr: &Chardev = chr;
unsafe {
use common::Opaque;
use migration::impl_vmstate_pointer;
-use crate::{
- bindings::{
- self, object_class_dynamic_cast, object_dynamic_cast, object_get_class,
- object_get_typename, object_new, object_ref, object_unref, TypeInfo,
- },
- cell::bql_locked,
+use crate::bindings::{
+ self, object_class_dynamic_cast, object_dynamic_cast, object_get_class, object_get_typename,
+ object_new, object_ref, object_unref, TypeInfo,
};
/// A safe wrapper around [`bindings::Object`].
impl<T: ObjectType> Drop for Owned<T> {
fn drop(&mut self) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
// SAFETY: creation method is unsafe, and whoever calls it has
// responsibility that the pointer is valid, and remains valid
// throughout the lifetime of the `Owned<T>` and its clones.
pub trait ObjectClassMethods: IsA<Object> {
/// Return a new reference counted instance of this class
fn new() -> Owned<Self> {
- assert!(bql_locked());
+ assert!(bql::is_locked());
// SAFETY: the object created by object_new is allocated on
// the heap and has a reference count of 1
unsafe {
use crate::{
bindings,
- cell::bql_locked,
irq::{IRQState, InterruptSource},
memory::MemoryRegion,
prelude::*,
/// region with a number that corresponds to the order of calls to
/// `init_mmio`.
fn init_mmio(&self, iomem: &MemoryRegion) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
unsafe {
bindings::sysbus_init_mmio(self.upcast().as_mut_ptr(), iomem.as_mut_ptr());
}
/// whoever creates the sysbus device will refer to the interrupts with
/// a number that corresponds to the order of calls to `init_irq`.
fn init_irq(&self, irq: &InterruptSource) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
unsafe {
bindings::sysbus_init_irq(self.upcast().as_mut_ptr(), irq.as_ptr());
}
// TODO: do we want a type like GuestAddress here?
fn mmio_addr(&self, id: u32) -> Option<u64> {
- assert!(bql_locked());
+ assert!(bql::is_locked());
// SAFETY: the BQL ensures that no one else writes to sbd.mmio[], and
// the SysBusDevice must be initialized to get an IsA<SysBusDevice>.
let sbd = unsafe { *self.upcast().as_ptr() };
// TODO: do we want a type like GuestAddress here?
fn mmio_map(&self, id: u32, addr: u64) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
let id: i32 = id.try_into().unwrap();
unsafe {
bindings::sysbus_mmio_map(self.upcast().as_mut_ptr(), id, addr);
// object_property_set_link) adds a reference to the IRQState,
// which can prolong its life
fn connect_irq(&self, id: u32, irq: &Owned<IRQState>) {
- assert!(bql_locked());
+ assert!(bql::is_locked());
let id: i32 = id.try_into().unwrap();
let irq: &IRQState = irq;
unsafe {
fn sysbus_realize(&self) {
// TODO: return an Error
- assert!(bql_locked());
+ assert!(bql::is_locked());
unsafe {
bindings::sysbus_realize(
self.upcast().as_mut_ptr(),
use std::{ffi::CStr, ptr::addr_of};
+use bql::BqlCell;
use migration::{VMStateDescription, VMStateDescriptionBuilder};
use qemu_api::{
- cell::{self, BqlCell},
prelude::*,
qdev::{DeviceImpl, DeviceState, ResettablePhasesImpl},
qom::{ObjectImpl, ParentField},
fn init_qom() {
static ONCE: BqlCell<bool> = BqlCell::new(false);
- cell::bql_start_test();
+ bql::start_test();
if !ONCE.get() {
unsafe {
module_call_init(module_init_type::MODULE_INIT_QOM);
slice,
};
+use bql::BqlCell;
use common::Opaque;
use migration::{
bindings::{
vmstate::{VMStateDescription, VMStateDescriptionBuilder, VMStateField},
vmstate_fields, vmstate_of, vmstate_unused, vmstate_validate,
};
-use qemu_api::cell::BqlCell;
const FOO_ARRAY_MAX: usize = 3;
projects / thirdparty / qemu.git / commitdiff
