GuestAddressSpace: mark the GuestMemory smart pointer as cloneable

This makes it possible to upgrade the short-lived pointer returned by
memory() to an owned pointer that can be stored.  The bound is already
provided by the trivial GuestAddressSpaces (references and Rc/Arc)
and also by ArcSwap via vorner/arc-swap#26.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

Author: bonzini

Cargo.toml

@@ -17,7 +17,7 @@ backend-atomic = ["arc-swap"]
 
 [dependencies]
 libc = ">=0.2.39"
-arc-swap = { version = ">=0.4.4", optional = true }
+arc-swap = { version = ">=0.4.5", optional = true }
 
 [target.'cfg(windows)'.dependencies.winapi]
 version = ">=0.3"

coverage_config.json

@@ -1,5 +1,5 @@
 {
-  "coverage_score": 85.6,
+  "coverage_score": 85.7,
   "exclude_path": "mmap_windows.rs",
   "crate_features": "backend-mmap,backend-atomic"
 }

src/atomic.rs

@@ -104,6 +104,14 @@ impl<M: GuestMemory> GuestMemoryLoadGuard<M> {
     }
 }
 
+impl<M: GuestMemory> Clone for GuestMemoryLoadGuard<M> {
+    fn clone(&self) -> Self {
+        GuestMemoryLoadGuard {
+            guard: Guard::from_inner(Arc::clone(&*self.guard)),
+        }
+    }
+}
+
 impl<M: GuestMemory> Deref for GuestMemoryLoadGuard<M> {
     type Target = M;
 
@@ -203,6 +211,22 @@ mod tests {
         assert!(mem3.find_region(GuestAddress(0x10000)).is_none());
     }
 
+    #[test]
+    fn test_clone_guard() {
+        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);
+        let mem = {
+            let guard1 = gm.memory();
+            Clone::clone(&guard1)
+        };
+        assert_eq!(mem.num_regions(), 2);
+    }
+
     #[test]
     fn test_atomic_hotplug() {
         let region_size = 0x1000;

src/guest_memory.rs

@@ -356,7 +356,7 @@ pub trait GuestAddressSpace {
     type M: GuestMemory;
 
     /// A type that provides access to the memory.
-    type T: Deref<Target = Self::M>;
+    type T: Clone + Deref<Target = Self::M>;
 
     /// Return an object (e.g. a reference or guard) that can be used
     /// to access memory through this address space.  The object provides