  1
   2
   3
@@ -166,12 +166,14 @@
 163
 164
 165
+166

-use std::convert::{AsMut, AsRef};
-use std::io;
-use std::ops;
-use std::os::unix::io::AsRawFd;
+use std::convert::{AsMut, AsRef};
+use std::io;
+use std::ops;
+use std::os::unix::io::AsRawFd;
 
+pub mod cap;
 mod fmt;
 pub mod kvm;
 pub mod kvm_sys;
@@ -184,9 +186,9 @@
 
 /// Helper to turn libc return values into an [io::Result](std::io::Result). Returns
 /// [`Error::last_os_error`](std::io::Error::last_os_error) if `ret < 0`.
-fn libcret(ret: libc::c_int) -> io::Result<libc::c_int> {
+fn libcret(ret: libc::c_int) -> io::Result<libc::c_int> {
     if ret < 0 {
-        Err(io::Error::last_os_error())
+        Err(io::Error::last_os_error())
     } else {
         Ok(ret)
     }
@@ -194,8 +196,8 @@
 
 /// Wrapper of `libc::ioctl` for KVM ioctls with one argument and returning an
 /// [`io::Result`](std::io::Result).
-fn ioctl<F: AsRawFd>(fd: &F, cmd: u64, arg: u64) -> io::Result<libc::c_int> {
-    libcret(unsafe { libc::ioctl(fd.as_raw_fd(), cmd, arg) })
+fn ioctl<F: AsRawFd>(fd: &F, cmd: u64, arg: u64) -> io::Result<libc::c_int> {
+    libcret(unsafe { libc::ioctl(fd.as_raw_fd(), cmd, arg) })
 }
 
 /// Wrapper to safely allocate memory for guest VMs.
@@ -211,20 +213,20 @@
 
 impl UserMem {
     /// Allocate a zero-initialized memory region of `len` bytes.
-    pub fn new(len: usize) -> io::Result<UserMem> {
+    pub fn new(len: usize) -> io::Result<UserMem> {
         let ptr = unsafe {
-            libc::mmap(
-                std::ptr::null_mut(),
+            libc::mmap(
+                std::ptr::null_mut(),
                 len,
-                libc::PROT_READ | libc::PROT_WRITE,
-                libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
+                libc::PROT_READ | libc::PROT_WRITE,
+                libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
                 -1,
                 0,
             )
         };
 
-        if ptr == libc::MAP_FAILED {
-            Err(io::Error::last_os_error())
+        if ptr == libc::MAP_FAILED {
+            Err(io::Error::last_os_error())
         } else {
             Ok(UserMem {
                 ptr: ptr.cast(),
@@ -239,10 +241,10 @@
     /// # Panics
     ///
     /// Panics if `init_from` is larger than the memory size `len`.
-    pub fn with_init(len: usize, init_from: &[u8]) -> io::Result<UserMem> {
-        assert!(len >= init_from.len());
+    pub fn with_init(len: usize, init_from: &[u8]) -> io::Result<UserMem> {
+        assert!(len >= init_from.len());
 
-        let mut m = UserMem::new(len)?;
+        let mut m = UserMem::new(len)?;
         m.load(PhysAddr(0), init_from);
         Ok(m)
     }
@@ -253,29 +255,29 @@
     ///
     /// Panics if `addr + data.len` is larger than the memory size `len`.
     pub fn load(&mut self, addr: PhysAddr, data: &[u8]) {
-        assert!(self.len >= addr.0 as usize + data.len());
+        assert!(self.len >= addr.0 as usize + data.len());
 
         let addr = addr.0 as usize;
         self.as_mut()[addr..addr + data.len()].copy_from_slice(data);
     }
 }
 
-impl ops::Drop for UserMem {
+impl ops::Drop for UserMem {
     /// Free underlying memory.
     fn drop(&mut self) {
-        unsafe { libc::munmap(self.ptr.cast(), self.len) };
+        unsafe { libc::munmap(self.ptr.cast(), self.len) };
     }
 }
 
 impl AsRef<[u8]> for UserMem {
     fn as_ref(&self) -> &[u8] {
-        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
+        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
     }
 }
 
 impl AsMut<[u8]> for UserMem {
     fn as_mut(&mut self) -> &mut [u8] {
-        unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) }
+        unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) }
     }
 }
 
@@ -284,27 +286,27 @@
 ///
 /// [kvm_run]: https://www.kernel.org/doc/html/latest/virt/kvm/api.html#the-kvm-run-structure
 struct KvmRun {
-    ptr: *mut kvm_sys::kvm_run,
+    ptr: *mut kvm_sys::kvm_run,
     len: usize,
 }
 
 impl KvmRun {
     /// Mmap the `struct kvm_run` for a given `VCPU` referenced by the argument file descriptor
     /// `vcpu`.
-    fn new<F: AsRawFd>(vcpu: &F, len: usize) -> io::Result<KvmRun> {
+    fn new<F: AsRawFd>(vcpu: &F, len: usize) -> io::Result<KvmRun> {
         let ptr = unsafe {
-            libc::mmap(
-                std::ptr::null_mut(),
+            libc::mmap(
+                std::ptr::null_mut(),
                 len,
-                libc::PROT_READ | libc::PROT_WRITE,
-                libc::MAP_SHARED,
+                libc::PROT_READ | libc::PROT_WRITE,
+                libc::MAP_SHARED,
                 vcpu.as_raw_fd(),
                 0,
             )
         };
 
-        if ptr == libc::MAP_FAILED {
-            Err(io::Error::last_os_error())
+        if ptr == libc::MAP_FAILED {
+            Err(io::Error::last_os_error())
         } else {
             Ok(KvmRun {
                 ptr: ptr.cast(),
@@ -314,24 +316,24 @@
     }
 }
 
-impl ops::Drop for KvmRun {
+impl ops::Drop for KvmRun {
     /// Munmap the mmaped `struct kvm_run`.
     fn drop(&mut self) {
-        unsafe { libc::munmap(self.ptr.cast(), self.len) };
+        unsafe { libc::munmap(self.ptr.cast(), self.len) };
     }
 }
 
-impl AsRef<kvm_sys::kvm_run> for KvmRun {
-    fn as_ref(&self) -> &kvm_sys::kvm_run {
-        unsafe { & *(self.ptr as *const kvm_sys::kvm_run) }
+impl AsRef<kvm_sys::kvm_run> for KvmRun {
+    fn as_ref(&self) -> &kvm_sys::kvm_run {
+        unsafe { &*(self.ptr as *const kvm_sys::kvm_run) }
     }
 }
 
-impl AsMut<kvm_sys::kvm_run> for KvmRun {
-    fn as_mut(&mut self) -> &mut kvm_sys::kvm_run {
-        unsafe { &mut *(self.ptr as *mut kvm_sys::kvm_run) }
+impl AsMut<kvm_sys::kvm_run> for KvmRun {
+    fn as_mut(&mut self) -> &mut kvm_sys::kvm_run {
+        unsafe { &mut *(self.ptr as *mut kvm_sys::kvm_run) }
     }
 }

-