refactor(vsock): make vsock reuse packets

Add rx_packet and tx_packet members to the Vsock
type and reuse them for RX and TX processing. This removed
overhead of creating new packets for each request.

As an additional improvement, we split VsockPacket
type into 2 types: VsockPacketRx and VsockPacketTx
which allows us to separate logic for RX and TX
processing.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

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

@@ -27,7 +27,7 @@ use vmm_sys_util::eventfd::EventFd;
 
 use super::super::super::DeviceError;
 use super::defs::uapi;
-use super::packet::{VsockPacket, VSOCK_PKT_HDR_SIZE};
+use super::packet::{VsockPacketRx, VsockPacketTx, VSOCK_PKT_HDR_SIZE};
 use super::{defs, VsockBackend};
 use crate::devices::virtio::device::{DeviceState, IrqTrigger, IrqType, VirtioDevice};
 use crate::devices::virtio::queue::Queue as VirtQueue;
@@ -68,6 +68,9 @@ pub struct Vsock<B> {
     // continuous triggers from happening before the device gets activated.
     pub(crate) activate_evt: EventFd,
     pub(crate) device_state: DeviceState,
+
+    pub rx_packet: VsockPacketRx,
+    pub tx_packet: VsockPacketTx,
 }
 
 // TODO: Detect / handle queue deadlock:
@@ -101,6 +104,8 @@ where
             irq_trigger: IrqTrigger::new().map_err(VsockError::EventFd)?,
             activate_evt: EventFd::new(libc::EFD_NONBLOCK).map_err(VsockError::EventFd)?,
             device_state: DeviceState::Inactive,
+            rx_packet: VsockPacketRx::default(),
+            tx_packet: VsockPacketTx::default(),
         })
     }
 
@@ -147,14 +152,14 @@ where
 
         while let Some(head) = self.queues[RXQ_INDEX].pop() {
             let index = head.index;
-            let used_len = match VsockPacket::from_rx_virtq_head(mem, head) {
-                Ok(mut pkt) => {
-                    if self.backend.recv_pkt(&mut pkt).is_ok() {
-                        match pkt.commit_hdr() {
+            let used_len = match self.rx_packet.parse(mem, head) {
+                Ok(()) => {
+                    if self.backend.recv_pkt(&mut self.rx_packet).is_ok() {
+                        match self.rx_packet.commit_hdr() {
                             // This addition cannot overflow, because packet length
                             // is previously validated against `MAX_PKT_BUF_SIZE`
                             // bound as part of `commit_hdr()`.
-                            Ok(()) => VSOCK_PKT_HDR_SIZE + pkt.len(),
+                            Ok(()) => VSOCK_PKT_HDR_SIZE + self.rx_packet.hdr.len(),
                             Err(err) => {
                                 warn!(
                                     "vsock: Error writing packet header to guest memory: \
@@ -200,8 +205,9 @@ where
 
         while let Some(head) = self.queues[TXQ_INDEX].pop() {
             let index = head.index;
-            let pkt = match VsockPacket::from_tx_virtq_head(mem, head) {
-                Ok(pkt) => pkt,
+            // let pkt = match VsockPacket::from_tx_virtq_head(mem, head) {
+            match self.tx_packet.parse(mem, head) {
+                Ok(()) => (),
                 Err(err) => {
                     error!("vsock: error reading TX packet: {:?}", err);
                     have_used = true;
@@ -214,7 +220,7 @@ where
                 }
             };
 
-            if self.backend.send_pkt(&pkt).is_err() {
+            if self.backend.send_pkt(&self.tx_packet).is_err() {
                 self.queues[TXQ_INDEX].undo_pop();
                 break;
             }

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

@@ -439,7 +439,9 @@ mod tests {
             // If the descriptor chain is already declared invalid, there's no reason to assemble
             // a packet.
             if let Some(rx_desc) = ctx.device.queues[RXQ_INDEX].pop() {
-                VsockPacket::from_rx_virtq_head(&test_ctx.mem, rx_desc).unwrap_err();
+                VsockPacketRx::default()
+                    .parse(&test_ctx.mem, rx_desc)
+                    .unwrap_err();
             }
         }
 
@@ -461,7 +463,9 @@ mod tests {
             ctx.guest_txvq.dtable[desc_idx].len.set(len);
 
             if let Some(tx_desc) = ctx.device.queues[TXQ_INDEX].pop() {
-                VsockPacket::from_tx_virtq_head(&test_ctx.mem, tx_desc).unwrap_err();
+                VsockPacketTx::default()
+                    .parse(&test_ctx.mem, tx_desc)
+                    .unwrap_err();
             }
         }
     }
@@ -486,13 +490,17 @@ mod tests {
         {
             let mut ctx = test_ctx.create_event_handler_context();
             let rx_desc = ctx.device.queues[RXQ_INDEX].pop().unwrap();
-            VsockPacket::from_rx_virtq_head(&test_ctx.mem, rx_desc).unwrap();
+            VsockPacketRx::default()
+                .parse(&test_ctx.mem, rx_desc)
+                .unwrap();
         }
 
         {
             let mut ctx = test_ctx.create_event_handler_context();
             let tx_desc = ctx.device.queues[TXQ_INDEX].pop().unwrap();
-            VsockPacket::from_tx_virtq_head(&test_ctx.mem, tx_desc).unwrap();
+            VsockPacketTx::default()
+                .parse(&test_ctx.mem, tx_desc)
+                .unwrap();
         }
 
         // Let's check what happens when the header descriptor is right before the gap.

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

@@ -22,13 +22,13 @@ mod unix;
 
 use std::os::unix::io::AsRawFd;
 
-use packet::VsockPacket;
 use vm_memory::GuestMemoryError;
 use vmm_sys_util::epoll::EventSet;
 
 pub use self::defs::uapi::VIRTIO_ID_VSOCK as TYPE_VSOCK;
 pub use self::defs::VSOCK_DEV_ID;
 pub use self::device::Vsock;
+use self::packet::{VsockPacketRx, VsockPacketTx};
 pub use self::unix::{VsockUnixBackend, VsockUnixBackendError};
 use crate::devices::virtio::iovec::IoVecError;
 use crate::devices::virtio::persist::PersistError as VirtioStateError;
@@ -174,10 +174,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) -> Result<(), VsockError>;
+    fn recv_pkt(&mut self, pkt: &mut VsockPacketRx) -> Result<(), VsockError>;
 
     /// Write/send a packet through the channel.
-    fn send_pkt(&mut self, pkt: &VsockPacket) -> Result<(), VsockError>;
+    fn send_pkt(&mut self, pkt: &VsockPacketTx) -> Result<(), VsockError>;
 
     /// Checks whether there is pending incoming data inside the channel, meaning that a subsequent
     /// call to `recv_pkt()` won't fail.