Add a blanket definition of ClassInitImpl<ObjectClass> that thunks
ObjectImpl::UNPARENT and overrides it in ObjectClass if it is not
None.
ClassInitImpl<DeviceClass> can now call its superclass's ClassInitImpl,
so that the C and Rust hierarchies match more closely.
This is mostly done as an example of implementing the metaclass
hierarchy under ClassInitImpl.
Signed-off-by: Paolo Bonzini <pbonz...@redhat.com>
---
rust/qemu-api/src/definitions.rs | 44 ++++++++++++++++++++++++++++---
rust/qemu-api/src/device_class.rs | 6 +++--
2 files changed, 45 insertions(+), 5 deletions(-)
diff --git a/rust/qemu-api/src/definitions.rs b/rust/qemu-api/src/definitions.rs
index 2429b9f53f0..958ea34decc 100644
--- a/rust/qemu-api/src/definitions.rs
+++ b/rust/qemu-api/src/definitions.rs
@@ -6,7 +6,7 @@
use std::{ffi::CStr, os::raw::c_void};
-use crate::bindings::{Object, ObjectClass, TypeInfo};
+use crate::bindings::{self, Object, ObjectClass, TypeInfo};
unsafe extern "C" fn rust_instance_init<T: ObjectImpl>(obj: *mut Object) {
// SAFETY: obj is an instance of T, since rust_instance_init<T>
@@ -115,6 +115,9 @@ pub trait ObjectImpl: ObjectType +
ClassInitImpl<Self::Class> {
class_data: core::ptr::null_mut(),
interfaces: core::ptr::null_mut(),
};
+
+ // methods on ObjectClass
+ const UNPARENT: Option<fn(&mut Self)> = None;
}
/// Internal trait used to automatically fill in a class struct.
@@ -128,7 +131,8 @@ pub trait ObjectImpl: ObjectType +
ClassInitImpl<Self::Class> {
///
/// Each struct will implement this trait with `T` equal to each
/// superclass. For example, a device should implement at least
-/// `ClassInitImpl<`[`DeviceClass`](crate::bindings::DeviceClass)`>`.
+/// `ClassInitImpl<`[`DeviceClass`](crate::bindings::DeviceClass)`>` and
+/// `ClassInitImpl<`[`ObjectClass`](crate::bindings::ObjectClass)`>`.
///
/// Fortunately, this is almost never necessary. Instead, the Rust
/// implementation of methods will usually come from a trait like
@@ -139,9 +143,13 @@ pub trait ObjectImpl: ObjectType +
ClassInitImpl<Self::Class> {
/// ```ignore
/// impl<T> ClassInitImpl<DeviceClass> for T
/// where
-/// T: DeviceImpl,
+/// T: ClassInitImpl<ObjectClass> + DeviceImpl,
/// ```
///
+/// The bound on `ClassInitImpl<ObjectClass>` is needed so that,
+/// after initializing the `DeviceClass` part of the class struct,
+/// the parent [`ObjectClass`] is initialized as well.
+///
/// The only case in which a manual implementation of the trait is needed
/// is for interfaces (note that there is no Rust example yet for using
/// interfaces). In this case, unlike the C case, the Rust class _has_
@@ -203,3 +211,33 @@ extern "C" fn ctor_fn() {
}
};
}
+
+/// # Safety
+///
+/// We expect the FFI user of this function to pass a valid pointer that
+/// can be downcasted to type `T`. We also expect the device is
+/// readable/writeable from one thread at any time.
+unsafe extern "C" fn rust_unparent_fn<T: ObjectImpl>(dev: *mut Object) {
+ unsafe {
+ assert!(!dev.is_null());
+ let mut state = core::ptr::NonNull::new_unchecked(dev.cast::<T>());
+ T::UNPARENT.unwrap()(state.as_mut());
+ }
+}
+
+impl<T> ClassInitImpl<ObjectClass> for T
+where
+ T: ObjectImpl,
+{
+ fn class_init(oc: &mut ObjectClass) {
+ if <T as ObjectImpl>::UNPARENT.is_some() {
+ oc.unparent = Some(rust_unparent_fn::<T>);
+ }
+ }
+}
+
+unsafe impl ObjectType for Object {
+ type Class = ObjectClass;
+ const TYPE_NAME: &'static CStr =
+ unsafe { CStr::from_bytes_with_nul_unchecked(bindings::TYPE_OBJECT) };
+}
diff --git a/rust/qemu-api/src/device_class.rs
b/rust/qemu-api/src/device_class.rs
index ee9ae7eeb74..285dfe582c7 100644
--- a/rust/qemu-api/src/device_class.rs
+++ b/rust/qemu-api/src/device_class.rs
@@ -5,7 +5,7 @@
use std::ffi::CStr;
use crate::{
- bindings::{self, DeviceClass, DeviceState, Error, Property,
VMStateDescription},
+ bindings::{self, DeviceClass, DeviceState, Error, ObjectClass, Property,
VMStateDescription},
definitions::ClassInitImpl,
prelude::*,
zeroable::Zeroable,
@@ -69,7 +69,7 @@ fn vmsd() -> Option<&'static VMStateDescription> {
impl<T> ClassInitImpl<DeviceClass> for T
where
- T: DeviceImpl,
+ T: ClassInitImpl<ObjectClass> + DeviceImpl,
{
fn class_init(dc: &mut DeviceClass) {
if <T as DeviceImpl>::REALIZE.is_some() {
@@ -86,6 +86,8 @@ fn class_init(dc: &mut DeviceClass) {
unsafe {
bindings::device_class_set_props(dc, <T as
DeviceImpl>::properties().as_ptr());
}
+
+ <T as ClassInitImpl<ObjectClass>>::class_init(&mut dc.parent_class);
}
}
--
2.47.1
