motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-07-27 04:13:53 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

rust: qom: remove operations on &mut

Browse source 
The dubious casts of mutable references to objects are not used
anymore: the wrappers for qdev_init_clock_in and for IRQ and MMIO
initialization can be called directly on the subclasses, without
casts, plus they take a shared reference so they can just use
"upcast()" instead of "upcast_mut()".  Remove them.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2024-12-13 17:54:33 +01:00
parent 5778ce9997
commit 094cd35913
4 changed files with 2 additions and 121 deletions
Download patch file Download diff file Expand all files Collapse all files

5
rust/qemu-api/src/memory.rs
View file

@ -175,11 +175,6 @@ impl MemoryRegion {
) {
unsafe {
Self::do_init_io(
// self.0.as_mut_ptr() needed because Rust tries to call
// ObjectDeref::as_mut_ptr() on "&mut Self", instead of coercing
// to "&Self" and then calling MemoryRegion::as_mut_ptr().
// Revisit if/when ObjectCastMut is not needed anymore; it is
// only used in a couple places for initialization.
self.0.as_mut_ptr(),
owner.cast::<Object>(),
&ops.0,

1
rust/qemu-api/src/prelude.rs
View file

@ -17,7 +17,6 @@ pub use crate::qom::InterfaceType;
pub use crate::qom::IsA;
pub use crate::qom::Object;
pub use crate::qom::ObjectCast;
pub use crate::qom::ObjectCastMut;
pub use crate::qom::ObjectDeref;
pub use crate::qom::ObjectClassMethods;
pub use crate::qom::ObjectMethods;

83
rust/qemu-api/src/qom.rs
View file

@ -463,90 +463,7 @@ where
impl<T: ObjectType> ObjectDeref for &T {}
impl<T: ObjectType> ObjectCast for &T {}
/// Trait for mutable type casting operations in the QOM hierarchy.
///
/// This trait provides the mutable counterparts to [`ObjectCast`]'s conversion
/// functions. Unlike `ObjectCast`, this trait returns `Result` for fallible
/// conversions to preserve the original smart pointer if the cast fails. This
/// is necessary because mutable references cannot be copied, so a failed cast
/// must return ownership of the original reference. For example:
///
/// ```ignore
/// let mut dev = get_device();
/// // If this fails, we need the original `dev` back to try something else
/// match dev.dynamic_cast_mut::<FooDevice>() {
/// Ok(foodev) => /* use foodev */,
/// Err(dev) => /* still have ownership of dev */
/// }
/// ```
pub trait ObjectCastMut: Sized + ObjectDeref + DerefMut
where
Self::Target: ObjectType,
{
/// Safely convert from a derived type to one of its parent types.
///
/// This is always safe; the [`IsA`] trait provides static verification
/// that `Self` dereferences to `U` or a child of `U`.
fn upcast_mut<'a, U: ObjectType>(self) -> &'a mut U
where
Self::Target: IsA<U>,
Self: 'a,
{
// SAFETY: soundness is declared via IsA<U>, which is an unsafe trait
unsafe { self.unsafe_cast_mut::<U>() }
}
/// Attempt to convert to a derived type.
///
/// Returns `Ok(..)` if the object is of type `U`, or `Err(self)` if the
/// object if the conversion failed. This is verified at runtime by
/// checking the object's type information.
fn downcast_mut<'a, U: IsA<Self::Target>>(self) -> Result<&'a mut U, Self>
where
Self: 'a,
{
self.dynamic_cast_mut::<U>()
}
/// Attempt to convert between any two types in the QOM hierarchy.
///
/// Returns `Ok(..)` if the object is of type `U`, or `Err(self)` if the
/// object if the conversion failed. This is verified at runtime by
/// checking the object's type information.
fn dynamic_cast_mut<'a, U: ObjectType>(self) -> Result<&'a mut U, Self>
where
Self: 'a,
{
unsafe {
// SAFETY: upcasting to Object is always valid, and the
// return type is either NULL or the argument itself
let result: *mut U =
object_dynamic_cast(self.as_object_mut_ptr(), U::TYPE_NAME.as_ptr()).cast();
result.as_mut().ok_or(self)
}
}
/// Convert to any QOM type without verification.
///
/// # Safety
///
/// What safety? You need to know yourself that the cast is correct; only
/// use when performance is paramount. It is still better than a raw
/// pointer `cast()`, which does not even check that you remain in the
/// realm of QOM `ObjectType`s.
///
/// `unsafe_cast::<Object>()` is always safe.
unsafe fn unsafe_cast_mut<'a, U: ObjectType>(self) -> &'a mut U
where
Self: 'a,
{
unsafe { &mut *self.as_mut_ptr::<Self::Target>().cast::<U>() }
}
}
impl<T: ObjectType> ObjectDeref for &mut T {}
impl<T: ObjectType> ObjectCastMut for &mut T {}
/// Trait a type must implement to be registered with QEMU.
pub trait ObjectImpl: ObjectType + IsA<Object> {