clean up: removed any leftover related to...

either vhost or vsock.

Signed-off-by: Diana Popa <[email protected]>

Author: dianpopa

sys_util/src/guest_memory.rs

@@ -328,34 +328,6 @@ impl GuestMemory {
         })
     }
 
-    /// Convert a GuestAddress into a pointer in the address space of this
-    /// process. This should only be necessary for giving addresses to the
-    /// kernel, as with vhost ioctls. Normal reads/writes to guest memory should
-    /// be done through `write_from_memory`, `read_obj_from_addr`, etc.
-    ///
-    /// # Arguments
-    /// * `guest_addr` - Guest address to convert.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use sys_util::{GuestAddress, GuestMemory};
-    /// # fn test_host_addr() -> Result<(), ()> {
-    ///     let start_addr = GuestAddress(0x1000);
-    ///     let mut gm = GuestMemory::new(&vec![(start_addr, 0x500)]).map_err(|_| ())?;
-    ///     let addr = gm.get_host_address(GuestAddress(0x1200)).unwrap();
-    ///     println!("Host address is {:p}", addr);
-    ///     Ok(())
-    /// # }
-    /// ```
-    pub fn get_host_address(&self, guest_addr: GuestAddress) -> Result<*const u8> {
-        self.do_in_region(guest_addr, |mapping, offset| {
-            // This is safe; `do_in_region` already checks that offset is in
-            // bounds.
-            Ok(unsafe { mapping.as_ptr().offset(offset as isize) } as *const u8)
-        })
-    }
-
     pub fn do_in_region<F, T>(&self, guest_addr: GuestAddress, cb: F) -> Result<T>
     where
         F: FnOnce(&MemoryMapping, usize) -> Result<T>,
@@ -462,31 +434,6 @@ mod tests {
         assert_eq!(val2, num2);
     }
 
-    // Get the base address of the mapping for a GuestAddress.
-    fn get_mapping(mem: &GuestMemory, addr: GuestAddress) -> Result<*const u8> {
-        mem.do_in_region(addr, |mapping, _| Ok(mapping.as_ptr() as *const u8))
-    }
-
-    #[test]
-    fn guest_to_host() {
-        let start_addr1 = GuestAddress(0x0);
-        let start_addr2 = GuestAddress(0x100);
-        let mem = GuestMemory::new(&vec![(start_addr1, 0x100), (start_addr2, 0x400)]).unwrap();
-
-        // Verify the host addresses match what we expect from the mappings.
-        let addr1_base = get_mapping(&mem, start_addr1).unwrap();
-        let addr2_base = get_mapping(&mem, start_addr2).unwrap();
-        let host_addr1 = mem.get_host_address(start_addr1).unwrap();
-        let host_addr2 = mem.get_host_address(start_addr2).unwrap();
-        assert_eq!(host_addr1, addr1_base);
-        assert_eq!(host_addr2, addr2_base);
-
-        // Check that a bad address returns an error.
-        let bad_addr = GuestAddress(0x123456);
-        assert!(mem.get_host_address(bad_addr).is_err());
-        format!("{:?}", mem.get_host_address(bad_addr));
-    }
-
     #[test]
     fn write_and_read_slice() {
         let start_addr = GuestAddress(0x1000);

sys_util/src/ioctl.rs

@@ -115,18 +115,18 @@ pub unsafe fn ioctl_with_mut_ptr<F: AsRawFd, T>(fd: &F, req: c_ulong, arg: *mut
 #[cfg(test)]
 mod tests {
     const TUNTAP: ::std::os::raw::c_uint = 0x54;
-    const VHOST: ::std::os::raw::c_uint = 0xaf;
+    const KVMIO: ::std::os::raw::c_uint = 0xAE;
 
-    ioctl_io_nr!(VHOST_SET_OWNER, VHOST, 0x01);
+    ioctl_io_nr!(KVM_CREATE_VM, KVMIO, 0x01);
     ioctl_ior_nr!(TUNGETFEATURES, TUNTAP, 0xcf, ::std::os::raw::c_uint);
     ioctl_iow_nr!(TUNSETQUEUE, TUNTAP, 0xd9, ::std::os::raw::c_int);
-    ioctl_iowr_nr!(VHOST_GET_VRING_BASE, VHOST, 0x12, ::std::os::raw::c_int);
+    ioctl_iowr_nr!(KVM_GET_MSR_INDEX_LIST, KVMIO, 0x2, ::std::os::raw::c_int);
 
     #[test]
     fn ioctl_macros() {
-        assert_eq!(0x0000af01, VHOST_SET_OWNER());
-        assert_eq!(0x800454cf, TUNGETFEATURES());
-        assert_eq!(0x400454d9, TUNSETQUEUE());
-        assert_eq!(0xc004af12, VHOST_GET_VRING_BASE());
+        assert_eq!(0x0000AE01, KVM_CREATE_VM());
+        assert_eq!(0x800454CF, TUNGETFEATURES());
+        assert_eq!(0x400454D9, TUNSETQUEUE());
+        assert_eq!(0xC004AE02, KVM_GET_MSR_INDEX_LIST());
     }
 }