build: update vm-memory requirement from 0.12.2 to 0.13.0

Updates the requirements on [vm-memory](https://github.com/rust-vmm/vm-memory) to permit the latest version.
- [Release notes](https://github.com/rust-vmm/vm-memory/releases)
- [Changelog](https://github.com/rust-vmm/vm-memory/blob/main/CHANGELOG.md)
- [Commits](rust-vmm/vm-memory@v0.12.2...v0.13.0)

---
updated-dependencies:
- dependency-name: vm-memory
  dependency-type: direct:production
...

In addition to the dependabot changes, this commit updates usages of
deprecated functions.

With vm-memory 0.13.0, we introduced versions of the Read and Write
traits for operations on guest memory (`VolatileRead` and
`VolatileWrite`). These replace various `Read` and `Write` based APIs
that had suboptional performance due to requiring to first copy all data
from guest memory to hypervisor memory to ensure soundness. See also
rust-vmm/vm-memory#217.

Signed-off-by: Patrick Roy <[email protected]>
Co-authored-by: dependabot[bot] <[email protected]>

Author: roypat

Cargo.toml

@@ -22,11 +22,11 @@ elf = []
 pe = []
 
 [dependencies]
-vm-memory = "0.12.2"
+vm-memory = "0.13.1"
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["html_reports"] }
-vm-memory = { version = "0.12.0", features = ["backend-mmap"] }
+vm-memory = { version = "0.13.1", features = ["backend-mmap"] }
 
 [[bench]]
 name = "main"

src/loader/aarch64/pe/mod.rs

@@ -14,9 +14,8 @@
 
 use std::fmt;
 use std::io::{Read, Seek, SeekFrom};
-use std::mem;
 
-use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestUsize};
+use vm_memory::{Address, ByteValued, GuestAddress, GuestMemory, GuestUsize, ReadVolatile};
 
 use super::super::{Error as KernelLoaderError, KernelLoader, KernelLoaderResult, Result};
 
@@ -112,17 +111,16 @@ impl KernelLoader for PE {
         _highmem_start_address: Option<GuestAddress>,
     ) -> Result<KernelLoaderResult>
     where
-        F: Read + Seek,
+        F: ReadVolatile + Read + Seek,
     {
         let kernel_size = kernel_image
             .seek(SeekFrom::End(0))
             .map_err(|_| Error::SeekImageEnd)? as usize;
         let mut arm64_header: arm64_image_header = Default::default();
         kernel_image.rewind().map_err(|_| Error::SeekImageHeader)?;
 
-        arm64_header
-            .as_bytes()
-            .read_from(0, kernel_image, mem::size_of::<arm64_image_header>())
+        kernel_image
+            .read_exact(arm64_header.as_mut_slice())
             .map_err(|_| Error::ReadImageHeader)?;
 
         if u32::from_le(arm64_header.magic) != 0x644d_5241 {
@@ -156,7 +154,7 @@ impl KernelLoader for PE {
 
         kernel_image.rewind().map_err(|_| Error::SeekImageHeader)?;
         guest_mem
-            .read_exact_from(mem_offset, kernel_image, kernel_size)
+            .read_exact_volatile_from(mem_offset, kernel_image, kernel_size)
             .map_err(|_| Error::ReadKernelImage)?;
 
         loader_result.kernel_end = mem_offset
@@ -182,7 +180,7 @@ pub fn load_dtb<F, M: GuestMemory>(
     dtb_image: &mut F,
 ) -> Result<()>
 where
-    F: Read + Seek,
+    F: ReadVolatile + Read + Seek,
 {
     let dtb_size = dtb_image
         .seek(SeekFrom::End(0))
@@ -192,7 +190,7 @@ where
     }
     dtb_image.rewind().map_err(|_| Error::SeekDtbStart)?;
     guest_mem
-        .read_exact_from(guest_addr, dtb_image, dtb_size)
+        .read_exact_volatile_from(guest_addr, dtb_image, dtb_size)
         .map_err(|_| Error::ReadDtbImage.into())
 }
 

src/loader/mod.rs

@@ -24,7 +24,7 @@ use std::io::{Read, Seek};
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 use vm_memory::ByteValued;
-use vm_memory::{Address, Bytes, GuestAddress, GuestMemory, GuestUsize};
+use vm_memory::{Address, Bytes, GuestAddress, GuestMemory, GuestUsize, ReadVolatile};
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 pub use crate::loader_gen::bootparam;
@@ -176,7 +176,7 @@ pub trait KernelLoader {
         highmem_start_address: Option<GuestAddress>,
     ) -> Result<KernelLoaderResult>
     where
-        F: Read + Seek;
+        F: Read + ReadVolatile + Seek;
 }
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]

src/loader/x86_64/bzimage/mod.rs

@@ -12,10 +12,9 @@
 #![cfg(all(feature = "bzimage", any(target_arch = "x86", target_arch = "x86_64")))]
 
 use std::fmt;
-use std::io::{Read, Seek, SeekFrom};
-use std::mem;
+use std::io::{Seek, SeekFrom};
 
-use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestUsize};
+use vm_memory::{Address, ByteValued, GuestAddress, GuestMemory, GuestUsize, ReadVolatile};
 
 use super::super::{
     bootparam, Error as KernelLoaderError, KernelLoader, KernelLoaderResult, Result,
@@ -108,7 +107,7 @@ impl KernelLoader for BzImage {
         highmem_start_address: Option<GuestAddress>,
     ) -> Result<KernelLoaderResult>
     where
-        F: Read + Seek,
+        F: ReadVolatile + Seek,
     {
         let mut kernel_size = kernel_image
             .seek(SeekFrom::End(0))
@@ -118,9 +117,8 @@ impl KernelLoader for BzImage {
             .map_err(|_| Error::SeekBzImageHeader)?;
 
         let mut boot_header = bootparam::setup_header::default();
-        boot_header
-            .as_bytes()
-            .read_from(0, kernel_image, mem::size_of::<bootparam::setup_header>())
+        kernel_image
+            .read_volatile(&mut boot_header.as_bytes())
             .map_err(|_| Error::ReadBzImageHeader)?;
 
         // If the `HdrS` magic number is not found at offset 0x202, the boot protocol version is
@@ -172,7 +170,7 @@ impl KernelLoader for BzImage {
             .seek(SeekFrom::Start(setup_size as u64))
             .map_err(|_| Error::SeekBzImageCompressedKernel)?;
         guest_mem
-            .read_exact_from(mem_offset, kernel_image, kernel_size)
+            .read_exact_volatile_from(mem_offset, kernel_image, kernel_size)
             .map_err(|_| Error::ReadBzImageCompressedKernel)?;
 
         loader_result.kernel_end = mem_offset
@@ -189,7 +187,7 @@ mod tests {
     use super::*;
 
     use std::fs::File;
-    use std::io::Cursor;
+    use std::io::{Cursor, Read};
     use std::process::Command;
     use vm_memory::{Address, GuestAddress};
     type GuestMemoryMmap = vm_memory::GuestMemoryMmap<()>;

src/loader/x86_64/elf/mod.rs

@@ -17,7 +17,7 @@ use std::io::{Read, Seek, SeekFrom};
 use std::mem;
 use std::result;
 
-use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestUsize};
+use vm_memory::{Address, ByteValued, GuestAddress, GuestMemory, GuestUsize, ReadVolatile};
 
 use crate::loader::{Error as KernelLoaderError, KernelLoader, KernelLoaderResult, Result};
 use crate::loader_gen::elf;
@@ -205,7 +205,7 @@ impl KernelLoader for Elf {
         highmem_start_address: Option<GuestAddress>,
     ) -> Result<KernelLoaderResult>
     where
-        F: Read + Seek,
+        F: Read + ReadVolatile + Seek,
     {
         kernel_image.rewind().map_err(|_| Error::SeekElfStart)?;
 
@@ -281,7 +281,7 @@ impl KernelLoader for Elf {
             };
 
             guest_mem
-                .read_exact_from(mem_offset, kernel_image, phdr.p_filesz as usize)
+                .read_exact_volatile_from(mem_offset, kernel_image, phdr.p_filesz as usize)
                 .map_err(|_| Error::ReadKernelImage)?;
 
             let kernel_end = mem_offset
@@ -309,7 +309,7 @@ const PVH_NOTE_STR_SZ: usize = 4;
 /// are found in the note header.
 fn parse_elf_note<F>(phdr: &elf::Elf64_Phdr, kernel_image: &mut F) -> Result<PvhBootCapability>
 where
-    F: Read + Seek,
+    F: Read + ReadVolatile + Seek,
 {
     // Type of note header that encodes a 32-bit entry point address to boot a guest kernel using
     // the PVH boot protocol.