descriptor_utils: Use copy_nonoverlapping

Replace the copy_{to,from} calls for VolatileSlice with
ptr::copy_nonoverlapping.  The copy_{to,from} implementations were doing
a volatile read/write per byte, which is significantly slower than just
using a memcpy.

Using copy_nonoverlapping should be safe here as that's how this was
implemented before the refactor.

BUG=chromium:1014999
TEST=unit tests

Change-Id: Iad29e76056ff3064a5fe7e816b517b4ac75eaaef
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/1866894
Commit-Queue: Chirantan Ekbote <chirantan@chromium.org>
Tested-by: Chirantan Ekbote <chirantan@chromium.org>
Reviewed-by: Stephen Barber <smbarber@chromium.org>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>

1 files changed, 13 insertions, 2 deletions

diff --git a/devices/src/virtio/descriptor_utils.rs b/devices/src/virtio/descriptor_utils.rs
index 80cc530..0c228ed 100644
--- a/devices/src/virtio/descriptor_utils.rs
+++ b/devices/src/virtio/descriptor_utils.rs
@@ -7,6 +7,7 @@ use std::collections::VecDeque;
 use std::fmt::{self, Display};
 use std::io::{self, Read, Write};
 use std::mem::{size_of, MaybeUninit};
+use std::ptr::copy_nonoverlapping;
 use std::result;
 
 use data_model::{DataInit, Le16, Le32, Le64, VolatileMemory, VolatileMemoryError, VolatileSlice};
@@ -313,7 +314,14 @@ impl<'a> io::Read for Reader<'a> {
                 // This is guaranteed by the implementation of `consume`.
                 debug_assert_eq!(vs.size(), cmp::min(rem.len() as u64, vs.size()));
 
-                vs.copy_to(rem);
+                // Safe because we have already verified that `vs` points to valid memory.
+                unsafe {
+                    copy_nonoverlapping(
+                        vs.as_ptr() as *const u8,
+                        rem.as_mut_ptr(),
+                        vs.size() as usize,
+                    );
+                }
                 let copied = vs.size() as usize;
                 rem = &mut rem[copied..];
                 total += copied;
@@ -445,7 +453,10 @@ impl<'a> io::Write for Writer<'a> {
                 // This is guaranteed by the implementation of `consume`.
                 debug_assert_eq!(vs.size(), cmp::min(rem.len() as u64, vs.size()));
 
-                vs.copy_from(rem);
+                // Safe because we have already verified that `vs` points to valid memory.
+                unsafe {
+                    copy_nonoverlapping(rem.as_ptr(), vs.as_ptr(), vs.size() as usize);
+                }
                 let copied = vs.size() as usize;
                 rem = &rem[copied..];
                 total += copied;