Replace impl VolatileMemory for &mut [u8]

Due to the API exposed by the VolatileMemory trait constructing
a VolatileSlice from an immutable reference, this impl allowed
mutation through an immutable reference. This is because the
signature of `get_slice` has its first argument desugar to
`&&mut [u8]` instead of `&mut [u8]` (note the double reference).
This caused undefined behavior due to a cast from immutable
reference to mutable pointer.

The implementation has been replaced with `From<&mut [u8]> for
VolatileSlice`, which is safe.

Since this impl was only used in testing code, the impact of this
breaking change should be low.

For the same reasons, the `VecMem` struct in volatile_memory::tests
has been removed.

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

benches/volatile.rs

@@ -4,19 +4,22 @@
 
 pub use criterion::{black_box, Criterion};
 use vm_memory::volatile_memory::VolatileMemory;
+use vm_memory::VolatileSlice;
 
 pub fn benchmark_for_volatile(c: &mut Criterion) {
     let mut a = [0xa5u8; 1024];
-    let a_ref = &mut a[..];
-    let v_ref8 = a_ref.get_slice(0, a_ref.len()).unwrap();
-    let v_ref16 = a_ref.get_slice(0, a_ref.len() / 2).unwrap();
+    let vslice = VolatileSlice::from(&mut a[..]);
+    let v_ref8 = vslice.get_slice(0, vslice.len()).unwrap();
     let mut d8 = [0u8; 1024];
-    let mut d16 = [0u16; 512];
 
     // Check performance for read operations.
     c.bench_function("VolatileSlice::copy_to_u8", |b| {
         b.iter(|| v_ref8.copy_to(black_box(&mut d8[..])))
     });
+
+    let v_ref16 = vslice.get_slice(0, vslice.len() / 2).unwrap();
+    let mut d16 = [0u16; 512];
+
     c.bench_function("VolatileSlice::copy_to_u16", |b| {
         b.iter(|| v_ref16.copy_to(black_box(&mut d16[..])))
     });
@@ -33,11 +36,11 @@ pub fn benchmark_for_volatile(c: &mut Criterion) {
 
 fn benchmark_volatile_copy_to_volatile_slice(c: &mut Criterion) {
     let mut a = [0xa5u8; 10240];
-    let a_ref = &mut a[..];
-    let a_slice = a_ref.get_slice(0, a_ref.len()).unwrap();
+    let vslice = VolatileSlice::from(&mut a[..]);
+    let a_slice = vslice.get_slice(0, vslice.len()).unwrap();
     let mut d = [0u8; 10240];
-    let d_ref = &mut d[..];
-    let d_slice = d_ref.get_slice(0, d_ref.len()).unwrap();
+    let vslice2 = VolatileSlice::from(&mut d[..]);
+    let d_slice = vslice2.get_slice(0, vslice2.len()).unwrap();
 
     c.bench_function("VolatileSlice::copy_to_volatile_slice", |b| {
         b.iter(|| black_box(a_slice).copy_to_volatile_slice(d_slice))