refractor: remove unneeded GuestMemoryMmap parameters

A VsockPacket now holds references into guest memory (via pointed inside
of the iovec abstraction), so we no longer need to carry around a tuple
of (VsockPacket, GuestMemoryMmap) to be able to read or write vsock
packets. Therefore, a lot of boilerplate code for passing guest memory
references can now go.

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

Author: roypat

src/vmm/src/devices/virtio/vsock/csm/connection.rs

@@ -95,7 +95,6 @@ use super::txbuf::TxBuf;
 use super::{defs, ConnState, PendingRx, PendingRxSet, VsockCsmError};
 use crate::devices::virtio::vsock::metrics::METRICS;
 use crate::logger::IncMetric;
-use crate::vstate::memory::GuestMemoryMmap;
 
 /// Trait that vsock connection backends need to implement.
 ///
@@ -160,11 +159,7 @@ where
     /// - `Err(VsockError::NoData)`: there was no data available with which to fill in the packet;
     /// - `Err(VsockError::PktBufMissing)`: the packet would've been filled in with data, but it is
     ///   missing the data buffer.
-    fn recv_pkt(
-        &mut self,
-        pkt: &mut VsockPacket,
-        _mem: &GuestMemoryMmap,
-    ) -> Result<(), VsockError> {
+    fn recv_pkt(&mut self, pkt: &mut VsockPacket) -> Result<(), VsockError> {
         // Perform some generic initialization that is the same for any packet operation (e.g.
         // source, destination, credit, etc).
         self.init_pkt(pkt);
@@ -296,7 +291,7 @@ where
     ///
     /// Returns:
     /// always `Ok(())`: the packet has been consumed;
-    fn send_pkt(&mut self, pkt: &VsockPacket, mem: &GuestMemoryMmap) -> Result<(), VsockError> {
+    fn send_pkt(&mut self, pkt: &VsockPacket) -> Result<(), VsockError> {
         // Update the peer credit information.
         self.peer_buf_alloc = pkt.buf_alloc();
         self.peer_fwd_cnt = Wrapping(pkt.fwd_cnt());
@@ -318,7 +313,7 @@ where
                 }
 
                 // Unwrapping here is safe, since we just checked `pkt.buf()` above.
-                if let Err(err) = self.send_bytes(mem, pkt) {
+                if let Err(err) = self.send_bytes(pkt) {
                     // If we can't write to the host stream, that's an unrecoverable error, so
                     // we'll terminate this connection.
                     warn!(
@@ -608,7 +603,7 @@ where
     ///
     /// Raw data can either be sent straight to the host stream, or to our TX buffer, if the
     /// former fails.
-    fn send_bytes(&mut self, _mem: &GuestMemoryMmap, pkt: &VsockPacket) -> Result<(), VsockError> {
+    fn send_bytes(&mut self, pkt: &VsockPacket) -> Result<(), VsockError> {
         let len = pkt.len() as usize;
 
         // If there is data in the TX buffer, that means we're already registered for EPOLLOUT
@@ -899,7 +894,7 @@ mod tests {
                         PEER_BUF_ALLOC,
                     );
                     assert!(conn.has_pending_rx());
-                    conn.recv_pkt(&mut rx_pkt, &vsock_test_ctx.mem).unwrap();
+                    conn.recv_pkt(&mut rx_pkt).unwrap();
                     assert_eq!(rx_pkt.op(), uapi::VSOCK_OP_RESPONSE);
                     conn
                 }
@@ -926,15 +921,11 @@ mod tests {
         }
 
         fn send(&mut self) {
-            self.conn
-                .send_pkt(&self.tx_pkt, &self._vsock_test_ctx.mem)
-                .unwrap();
+            self.conn.send_pkt(&self.tx_pkt).unwrap();
         }
 
         fn recv(&mut self) {
-            self.conn
-                .recv_pkt(&mut self.rx_pkt, &self._vsock_test_ctx.mem)
-                .unwrap();
+            self.conn.recv_pkt(&mut self.rx_pkt).unwrap();
         }
 
         fn notify_epollin(&mut self) {
@@ -1028,7 +1019,7 @@ mod tests {
         assert_eq!(&buf, data);
 
         // There's no more data in the stream, so `recv_pkt` should yield `VsockError::NoData`.
-        match ctx.conn.recv_pkt(&mut ctx.tx_pkt, &ctx._vsock_test_ctx.mem) {
+        match ctx.conn.recv_pkt(&mut ctx.tx_pkt) {
             Err(VsockError::NoData) => (),
             other => panic!("{:?}", other),
         }

src/vmm/src/devices/virtio/vsock/device.rs

@@ -150,7 +150,7 @@ where
             let index = head.index;
             let used_len = match VsockPacket::from_rx_virtq_head(head) {
                 Ok(mut pkt) => {
-                    if self.backend.recv_pkt(&mut pkt, mem).is_ok() {
+                    if self.backend.recv_pkt(&mut pkt).is_ok() {
                         match pkt.commit_hdr() {
                             // This addition cannot overflow, because packet length
                             // is previously validated against `MAX_PKT_BUF_SIZE`
@@ -215,7 +215,7 @@ where
                 }
             };
 
-            if self.backend.send_pkt(&pkt, mem).is_err() {
+            if self.backend.send_pkt(&pkt).is_err() {
                 self.queues[TXQ_INDEX].undo_pop();
                 break;
             }

src/vmm/src/devices/virtio/vsock/event_handler.rs

@@ -205,7 +205,7 @@ mod tests {
     use super::*;
     use crate::devices::virtio::vsock::packet::VSOCK_PKT_HDR_SIZE;
     use crate::devices::virtio::vsock::test_utils::{EventHandlerContext, TestContext};
-    use crate::vstate::memory::{Bytes, GuestMemoryExtension};
+    use crate::vstate::memory::{Bytes, GuestMemoryExtension, GuestMemoryMmap};
 
     #[test]
     fn test_txq_event() {

src/vmm/src/devices/virtio/vsock/mod.rs

@@ -32,7 +32,6 @@ pub use self::device::Vsock;
 pub use self::unix::{VsockUnixBackend, VsockUnixBackendError};
 use crate::devices::virtio::iovec::IoVecError;
 use crate::devices::virtio::persist::PersistError as VirtioStateError;
-use crate::vstate::memory::GuestMemoryMmap;
 
 mod defs {
     use crate::devices::virtio::queue::FIRECRACKER_MAX_QUEUE_SIZE;
@@ -172,10 +171,10 @@ pub trait VsockEpollListener: AsRawFd {
 ///       - `send_pkt(&pkt)` will fetch data from `pkt`, and place it into the channel.
 pub trait VsockChannel {
     /// Read/receive an incoming packet from the channel.
-    fn recv_pkt(&mut self, pkt: &mut VsockPacket, mem: &GuestMemoryMmap) -> Result<(), VsockError>;
+    fn recv_pkt(&mut self, pkt: &mut VsockPacket) -> Result<(), VsockError>;
 
     /// Write/send a packet through the channel.
-    fn send_pkt(&mut self, pkt: &VsockPacket, mem: &GuestMemoryMmap) -> Result<(), VsockError>;
+    fn send_pkt(&mut self, pkt: &VsockPacket) -> Result<(), VsockError>;
 
     /// Checks whether there is pending incoming data inside the channel, meaning that a subsequent
     /// call to `recv_pkt()` won't fail.

src/vmm/src/devices/virtio/vsock/test_utils.rs

@@ -61,11 +61,7 @@ impl Default for TestBackend {
 }
 
 impl VsockChannel for TestBackend {
-    fn recv_pkt(
-        &mut self,
-        pkt: &mut VsockPacket,
-        _mem: &GuestMemoryMmap,
-    ) -> Result<(), VsockError> {
+    fn recv_pkt(&mut self, pkt: &mut VsockPacket) -> Result<(), VsockError> {
         let cool_buf = [0xDu8, 0xE, 0xA, 0xD, 0xB, 0xE, 0xE, 0xF];
         match self.rx_err.take() {
             None => {
@@ -84,7 +80,7 @@ impl VsockChannel for TestBackend {
         }
     }
 
-    fn send_pkt(&mut self, _pkt: &VsockPacket, _mem: &GuestMemoryMmap) -> Result<(), VsockError> {
+    fn send_pkt(&mut self, _pkt: &VsockPacket) -> Result<(), VsockError> {
         match self.tx_err.take() {
             None => {
                 self.tx_ok_cnt += 1;

src/vmm/src/devices/virtio/vsock/unix/muxer.rs

@@ -47,7 +47,6 @@ use super::muxer_rxq::MuxerRxQ;
 use super::{defs, MuxerConnection, VsockUnixBackendError};
 use crate::devices::virtio::vsock::metrics::METRICS;
 use crate::logger::IncMetric;
-use crate::vstate::memory::GuestMemoryMmap;
 
 /// A unique identifier of a `MuxerConnection` object. Connections are stored in a hash map,
 /// keyed by a `ConnMapKey` object.
@@ -116,7 +115,7 @@ impl VsockChannel for VsockMuxer {
     /// Retuns:
     /// - `Ok(())`: `pkt` has been successfully filled in; or
     /// - `Err(VsockError::NoData)`: there was no available data with which to fill in the packet.
-    fn recv_pkt(&mut self, pkt: &mut VsockPacket, mem: &GuestMemoryMmap) -> Result<(), VsockError> {
+    fn recv_pkt(&mut self, pkt: &mut VsockPacket) -> Result<(), VsockError> {
         // We'll look for instructions on how to build the RX packet in the RX queue. If the
         // queue is empty, that doesn't necessarily mean we don't have any pending RX, since
         // the queue might be out-of-sync. If that's the case, we'll attempt to sync it first,
@@ -152,7 +151,7 @@ impl VsockChannel for VsockMuxer {
                     let mut conn_res = Err(VsockError::NoData);
                     let mut do_pop = true;
                     self.apply_conn_mutation(key, |conn| {
-                        conn_res = conn.recv_pkt(pkt, mem);
+                        conn_res = conn.recv_pkt(pkt);
                         do_pop = !conn.has_pending_rx();
                     });
                     if do_pop {
@@ -189,7 +188,7 @@ impl VsockChannel for VsockMuxer {
     /// Returns:
     /// always `Ok(())` - the packet has been consumed, and its virtio TX buffers can be
     /// returned to the guest vsock driver.
-    fn send_pkt(&mut self, pkt: &VsockPacket, mem: &GuestMemoryMmap) -> Result<(), VsockError> {
+    fn send_pkt(&mut self, pkt: &VsockPacket) -> Result<(), VsockError> {
         let conn_key = ConnMapKey {
             local_port: pkt.dst_port(),
             peer_port: pkt.src_port(),
@@ -243,7 +242,7 @@ impl VsockChannel for VsockMuxer {
         // Alright, everything looks in order - forward this packet to its owning connection.
         let mut res: Result<(), VsockError> = Ok(());
         self.apply_conn_mutation(conn_key, |conn| {
-            res = conn.send_pkt(pkt, mem);
+            res = conn.send_pkt(pkt);
         });
 
         res
@@ -884,15 +883,11 @@ mod tests {
         }
 
         fn send(&mut self) {
-            self.muxer
-                .send_pkt(&self.tx_pkt, &self._vsock_test_ctx.mem)
-                .unwrap();
+            self.muxer.send_pkt(&self.tx_pkt).unwrap();
         }
 
         fn recv(&mut self) {
-            self.muxer
-                .recv_pkt(&mut self.rx_pkt, &self._vsock_test_ctx.mem)
-                .unwrap();
+            self.muxer.recv_pkt(&mut self.rx_pkt).unwrap();
         }
 
         fn notify_muxer(&mut self) {