From 0ed8decf5206935c49a56ca06ca34a8b95fa9b41 Mon Sep 17 00:00:00 2001
From: Liu Jiang <gerry@linux.alibaba.com>
Date: Tue, 8 Mar 2022 23:56:04 +0800
Subject: [PATCH] Add new method as_any() to GuestAddressSpace

Add new method as_any() to GuestAddressSpace, which returns reference
to a std::any::Any trait object. Then downcast_ref() could be used to
get the concrete type of GuestAddressSpace trait object.

Signed-off-by: Liu Jiang <gerry@linux.alibaba.com>
---
 CHANGELOG.md        |  5 +++++
 src/atomic.rs       | 26 ++++++++++++++++++++++++--
 src/guest_memory.rs | 32 +++++++++++++++++++++++++++++---
 3 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2a6a4870..9171fc6d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,11 @@
 # Changelog
 ## [Unreleased]
 
+### Added
+
+- [[192]](https://github.com/rust-vmm/vm-memory/pull/192): Add new method
+  as_any() to GuestAddressSpace
+
 ## [v0.8.0]
 
 ### Fixed
diff --git a/src/atomic.rs b/src/atomic.rs
index bb5693b4..36b087d0 100644
--- a/src/atomic.rs
+++ b/src/atomic.rs
@@ -12,6 +12,7 @@
 extern crate arc_swap;
 
 use arc_swap::{ArcSwap, Guard};
+use std::any::Any;
 use std::ops::Deref;
 use std::sync::{Arc, LockResult, Mutex, MutexGuard, PoisonError};
 
@@ -75,13 +76,17 @@ impl<M: GuestMemory> GuestMemoryAtomic<M> {
     }
 }
 
-impl<M: GuestMemory> GuestAddressSpace for GuestMemoryAtomic<M> {
-    type T = GuestMemoryLoadGuard<M>;
+impl<M: GuestMemory + 'static> GuestAddressSpace for GuestMemoryAtomic<M> {
     type M = M;
+    type T = GuestMemoryLoadGuard<M>;
 
     fn memory(&self) -> Self::T {
         GuestMemoryLoadGuard { guard: self.load() }
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 /// A guard that provides temporary access to a `GuestMemoryAtomic`.  This
@@ -148,6 +153,23 @@ mod tests {
     type GuestRegionMmap = crate::GuestRegionMmap<()>;
     type GuestMemoryMmapAtomic = GuestMemoryAtomic<GuestMemoryMmap>;
 
+    #[test]
+    fn test_as_any() {
+        let region_size = 0x400;
+        let regions = vec![
+            (GuestAddress(0x0), region_size),
+            (GuestAddress(0x1000), region_size),
+        ];
+        let gmm = GuestMemoryMmap::from_ranges(&regions).unwrap();
+        let gm = GuestMemoryMmapAtomic::new(gmm);
+
+        assert!(gm
+            .as_any()
+            .downcast_ref::<GuestMemoryMmapAtomic>()
+            .is_some());
+        assert!(gm.as_any().downcast_ref::<String>().is_none());
+    }
+
     #[test]
     fn test_atomic_memory() {
         let region_size = 0x400;
diff --git a/src/guest_memory.rs b/src/guest_memory.rs
index 6bbd02f1..f0e24c19 100644
--- a/src/guest_memory.rs
+++ b/src/guest_memory.rs
@@ -41,6 +41,7 @@
 //! via pointers, references, or slices returned by methods of `GuestMemory`,`GuestMemoryRegion`,
 //! `VolatileSlice`, `VolatileRef`, or `VolatileArrayRef`.
 
+use std::any::Any;
 use std::convert::From;
 use std::fmt::{self, Display};
 use std::fs::File;
@@ -400,33 +401,48 @@ pub trait GuestAddressSpace {
     /// to access memory through this address space.  The object provides
     /// a consistent snapshot of the memory map.
     fn memory(&self) -> Self::T;
+
+    /// Cast `self` to a dynamic trait object of `std::any::Any`.
+    fn as_any(&self) -> &dyn Any;
 }
 
-impl<M: GuestMemory> GuestAddressSpace for &M {
+impl<M: GuestMemory + 'static> GuestAddressSpace for &M {
     type M = M;
     type T = Self;
 
     fn memory(&self) -> Self {
         self
     }
+
+    fn as_any(&self) -> &dyn Any {
+        *self
+    }
 }
 
-impl<M: GuestMemory> GuestAddressSpace for Rc<M> {
+impl<M: GuestMemory + 'static> GuestAddressSpace for Rc<M> {
     type M = M;
     type T = Self;
 
     fn memory(&self) -> Self {
         self.clone()
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
-impl<M: GuestMemory> GuestAddressSpace for Arc<M> {
+impl<M: GuestMemory + 'static> GuestAddressSpace for Arc<M> {
     type M = M;
     type T = Self;
 
     fn memory(&self) -> Self {
         self.clone()
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 /// Lifetime generic associated iterators. The actual iterator type is defined through associated
@@ -1256,4 +1272,14 @@ mod tests {
         let r = mem.find_region(addr).unwrap();
         assert_eq!(r.is_hugetlbfs(), None);
     }
+
+    #[cfg(feature = "backend-mmap")]
+    #[test]
+    fn test_as_any() {
+        let addr = GuestAddress(0x1000);
+        let mem = &GuestMemoryMmap::from_ranges(&[(addr, 0x1000)]).unwrap();
+
+        assert!(mem.as_any().downcast_ref::<GuestMemoryMmap>().is_some());
+        assert!(mem.as_any().downcast_ref::<String>().is_none());
+    }
 }