brand new

Signed-off-by: aerosouund <aerosound161@gmail.com>

Author: aerosouund

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

@@ -13,6 +13,7 @@ use std::ops::Deref;
 use std::sync::{Arc, Mutex};
 
 use libc::{EAGAIN, iovec};
+use serde::{Deserialize, Serialize};
 use vmm_sys_util::eventfd::EventFd;
 
 use super::NET_QUEUE_MAX_SIZE;
@@ -29,7 +30,7 @@ use crate::devices::virtio::iovec::{
     IoVecBuffer, IoVecBufferMut, IoVecError, ParsedDescriptorChain,
 };
 use crate::devices::virtio::net::metrics::{NetDeviceMetrics, NetMetricsPerDevice};
-use crate::devices::virtio::net::tap::Tap;
+use crate::devices::virtio::net::tap::{NetDevBackend, PasstBackend, Tap};
 use crate::devices::virtio::net::{
     MAX_BUFFER_SIZE, NET_QUEUE_SIZES, NetError, NetQueue, RX_INDEX, TX_INDEX, generated,
 };
@@ -49,6 +50,19 @@ use crate::vstate::memory::{ByteValued, GuestMemoryMmap};
 
 const FRAME_HEADER_MAX_LEN: usize = PAYLOAD_OFFSET + ETH_IPV4_FRAME_LEN;
 
+const PASST_VIRTIO_FEATURES: u64 =
+    (1 << VIRTIO_F_VERSION_1) | (1 << VIRTIO_NET_F_MRG_RXBUF) | (1 << VIRTIO_RING_F_EVENT_IDX);
+
+const TAP_VIRTIO_FEATURES: u64 = (1 << VIRTIO_NET_F_GUEST_CSUM)
+    | (1 << VIRTIO_NET_F_CSUM)
+    | (1 << VIRTIO_NET_F_GUEST_TSO4)
+    | (1 << VIRTIO_NET_F_GUEST_TSO6)
+    | (1 << VIRTIO_NET_F_GUEST_UFO)
+    | (1 << VIRTIO_NET_F_HOST_TSO4)
+    | (1 << VIRTIO_NET_F_HOST_TSO6)
+    | (1 << VIRTIO_NET_F_HOST_UFO)
+    | (1 << VIRTIO_F_VERSION_1);
+
 pub(crate) const fn vnet_hdr_len() -> usize {
     mem::size_of::<virtio_net_hdr_v1>()
 }
@@ -60,6 +74,13 @@ const fn frame_hdr_len() -> usize {
     vnet_hdr_len() + FRAME_HEADER_MAX_LEN
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum NetDevBackendType {
+    Passt(String), // The string denotes the passt socket path
+    Tap(String),   // The string denotes the tap device name
+}
+
 // Frames being sent/received through the network device model have a VNET header. This
 // function returns a slice which holds the L2 frame bytes without this header.
 fn frame_bytes_from_buf(buf: &[u8]) -> Result<&[u8], NetError> {
@@ -237,7 +258,7 @@ pub struct Net {
     pub(crate) id: String,
 
     /// The backend for this device: a tap.
-    pub tap: Tap,
+    pub backend: Box<dyn NetDevBackend>,
 
     pub(crate) avail_features: u64,
     pub(crate) acked_features: u64,
@@ -269,24 +290,17 @@ pub struct Net {
 
 impl Net {
     /// Create a new virtio network device with the given TAP interface.
-    pub fn new_with_tap(
+    pub fn new_with_backend(
         id: String,
-        tap: Tap,
+        backend: Box<dyn NetDevBackend>,
         guest_mac: Option<MacAddr>,
         rx_rate_limiter: RateLimiter,
         tx_rate_limiter: RateLimiter,
     ) -> Result<Self, NetError> {
-        let mut avail_features = (1 << VIRTIO_NET_F_GUEST_CSUM)
-            | (1 << VIRTIO_NET_F_CSUM)
-            | (1 << VIRTIO_NET_F_GUEST_TSO4)
-            | (1 << VIRTIO_NET_F_GUEST_TSO6)
-            | (1 << VIRTIO_NET_F_GUEST_UFO)
-            | (1 << VIRTIO_NET_F_HOST_TSO4)
-            | (1 << VIRTIO_NET_F_HOST_TSO6)
-            | (1 << VIRTIO_NET_F_HOST_UFO)
-            | (1 << VIRTIO_F_VERSION_1)
-            | (1 << VIRTIO_NET_F_MRG_RXBUF)
-            | (1 << VIRTIO_RING_F_EVENT_IDX);
+        let mut avail_features = match backend.save() {
+            NetDevBackendType::Passt(_) => PASST_VIRTIO_FEATURES,
+            NetDevBackendType::Tap(_) => TAP_VIRTIO_FEATURES,
+        };
 
         let mut config_space = ConfigSpace::default();
         if let Some(mac) = guest_mac {
@@ -305,7 +319,7 @@ impl Net {
 
         Ok(Net {
             id: id.clone(),
-            tap,
+            backend: backend,
             avail_features,
             acked_features: 0u64,
             queues,
@@ -328,28 +342,37 @@ impl Net {
     /// Create a new virtio network device given the interface name.
     pub fn new(
         id: String,
-        tap_if_name: &str,
+        backend_identifier: &str,
         guest_mac: Option<MacAddr>,
         rx_rate_limiter: RateLimiter,
         tx_rate_limiter: RateLimiter,
+        backend_type: NetDevBackendType,
     ) -> Result<Self, NetError> {
-        let tap = Tap::open_named(tap_if_name).map_err(NetError::TapOpen)?;
-
         let vnet_hdr_size = i32::try_from(vnet_hdr_len()).unwrap();
-        tap.set_vnet_hdr_size(vnet_hdr_size)
-            .map_err(NetError::TapSetVnetHdrSize)?;
+        let backend: Box<dyn NetDevBackend> = match backend_type {
+            NetDevBackendType::Passt(path) => {
+                // id is passed as the socket path in the case of socket backend
+                Box::new(PasstBackend::new(path).map_err(|_| NetError::SocketOpen())?)
+            }
+            NetDevBackendType::Tap(tap_if_name) => {
+                let mut tap = Tap::open_named(&tap_if_name).map_err(NetError::TapOpen)?;
+                tap.set_vnet_hdr_size(vnet_hdr_size)
+                    .map_err(NetError::TapSetVnetHdrSize)?;
+                Box::new(tap)
+            }
+        };
 
-        Self::new_with_tap(id, tap, guest_mac, rx_rate_limiter, tx_rate_limiter)
+        Self::new_with_backend(id, backend, guest_mac, rx_rate_limiter, tx_rate_limiter)
     }
 
     /// Provides the MAC of this net device.
     pub fn guest_mac(&self) -> Option<&MacAddr> {
         self.guest_mac.as_ref()
     }
 
-    /// Provides the host IFACE name of this net device.
-    pub fn iface_name(&self) -> String {
-        self.tap.if_name_as_str().to_string()
+    /// Provides the identifier of this device.
+    pub fn identifier(&self) -> String {
+        self.backend.identifier().to_string()
     }
 
     /// Provides the MmdsNetworkStack of this net device.
@@ -499,7 +522,7 @@ impl Net {
         rate_limiter: &mut RateLimiter,
         headers: &mut [u8],
         frame_iovec: &IoVecBuffer,
-        tap: &mut Tap,
+        backend: &mut Box<dyn NetDevBackend>,
         guest_mac: Option<MacAddr>,
         net_metrics: &NetDeviceMetrics,
     ) -> Result<bool, NetError> {
@@ -573,7 +596,7 @@ impl Net {
         }
 
         let _metric = net_metrics.tap_write_agg.record_latency_metrics();
-        match Self::write_tap(tap, frame_iovec) {
+        match Self::write_backend(backend, frame_iovec) {
             Ok(_) => {
                 let len = u64::from(frame_iovec.len());
                 net_metrics.tx_bytes_count.add(len);
@@ -746,12 +769,16 @@ impl Net {
                 break;
             }
 
+            // where is the tx buffer allocated from ? does this mean we buffer this data in the firecracker
+            // process memory ? do we not have this zero copy trick we did in vsock ?
+            // expl: write whats in the tx buffer to the tap interface
+            // but wait. when did we even fill the tx buffer ?
             let frame_consumed_by_mmds = Self::write_to_mmds_or_tap(
                 self.mmds_ns.as_mut(),
                 &mut self.tx_rate_limiter,
                 &mut self.tx_frame_headers,
                 &self.tx_buffer,
-                &mut self.tap,
+                &mut self.backend,
                 self.guest_mac,
                 &self.metrics,
             )
@@ -839,15 +866,21 @@ impl Net {
     ///
     /// `self.rx_buffer` needs to have at least one descriptor chain parsed
     pub unsafe fn read_tap(&mut self) -> std::io::Result<usize> {
-        let slice = if self.has_feature(VIRTIO_NET_F_MRG_RXBUF as u64) {
+        // if we have the merge feature (evaluates to true) we get all chains
+        // let slice = if self.has_feature(VIRTIO_NET_F_MRG_RXBUF as u64) {
+
+        let slice = if false {
             self.rx_buffer.all_chains_slice_mut()
         } else {
             self.rx_buffer.single_chain_slice_mut()
         };
-        self.tap.read_iovec(slice)
+        self.backend.read_iovec(slice)
     }
 
-    fn write_tap(tap: &mut Tap, buf: &IoVecBuffer) -> std::io::Result<usize> {
+    fn write_backend(
+        tap: &mut Box<dyn NetDevBackend>,
+        buf: &IoVecBuffer,
+    ) -> std::io::Result<usize> {
         tap.write_iovec(buf)
     }
 
@@ -1041,10 +1074,13 @@ impl VirtioDevice for Net {
             }
         }
 
+        // ammar: we should try to fully understand offload
         let supported_flags: u32 = Net::build_tap_offload_features(self.acked_features);
-        self.tap
-            .set_offload(supported_flags)
-            .map_err(super::super::ActivateError::TapSetOffload)?;
+        if let NetDevBackendType::Tap(_) = self.backend.save() {
+            self.backend
+                .set_offload(supported_flags)
+                .map_err(super::super::ActivateError::TapSetOffload)?;
+        }
 
         self.rx_buffer.min_buffer_size = self.minimum_rx_buffer_size();
 

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

@@ -46,8 +46,9 @@ impl Net {
         )) {
             error!("Failed to register tx queue event: {}", err);
         }
+        let fd = &self.backend.as_raw_fd();
         if let Err(err) = ops.add(Events::with_data(
-            &self.tap,
+            fd,
             Self::PROCESS_TAP_RX,
             EventSet::IN | EventSet::EDGE_TRIGGERED,
         )) {

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

@@ -47,6 +47,8 @@ pub enum NetQueue {
 pub enum NetError {
     /// Open tap device failed: {0}
     TapOpen(TapError),
+    /// Socket backend opening failed
+    SocketOpen(),
     /// Setting vnet header size failed: {0}
     TapSetVnetHdrSize(TapError),
     /// EventFd error: {0}

src/vmm/src/devices/virtio/net/persist.rs

@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 use super::device::{Net, RxBuffers};
 use super::{NET_NUM_QUEUES, NET_QUEUE_MAX_SIZE, RX_INDEX, TapError};
 use crate::devices::virtio::device::{ActiveState, DeviceState, VirtioDeviceType};
+use crate::devices::virtio::net::device::NetDevBackendType;
 use crate::devices::virtio::persist::{PersistError as VirtioStateError, VirtioDeviceState};
 use crate::devices::virtio::transport::VirtioInterrupt;
 use crate::mmds::data_store::Mmds;
@@ -24,6 +25,7 @@ use crate::vstate::memory::GuestMemoryMmap;
 
 /// Information about the network config's that are saved
 /// at snapshot.
+/// ammar: if i snapshot a passt vm and restore it, will i get the same mac?
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct NetConfigSpaceState {
     guest_mac: Option<MacAddr>,
@@ -41,6 +43,7 @@ pub struct NetState {
     pub mmds_ns: Option<MmdsNetworkStackState>,
     config_space: NetConfigSpaceState,
     pub virtio_state: VirtioDeviceState,
+    pub backend_type: NetDevBackendType,
 }
 
 /// Auxiliary structure for creating a device when resuming from a snapshot.
@@ -73,16 +76,18 @@ impl Persist<'_> for Net {
     type Error = NetPersistError;
 
     fn save(&self) -> Self::State {
+        // we need to figure out the underlying backend type here so we can persist properly
         NetState {
             id: self.id.clone(),
-            tap_if_name: self.iface_name(),
+            tap_if_name: self.identifier(),
             rx_rate_limiter_state: self.rx_rate_limiter.save(),
             tx_rate_limiter_state: self.tx_rate_limiter.save(),
             mmds_ns: self.mmds_ns.as_ref().map(|mmds| mmds.save()),
             config_space: NetConfigSpaceState {
                 guest_mac: self.guest_mac,
             },
             virtio_state: VirtioDeviceState::from_device(self),
+            backend_type: self.backend.save(),
         }
     }
 
@@ -95,10 +100,11 @@ impl Persist<'_> for Net {
         let tx_rate_limiter = RateLimiter::restore((), &state.tx_rate_limiter_state)?;
         let mut net = Net::new(
             state.id.clone(),
-            &state.tap_if_name,
+            &state.tap_if_name, // make this not tap name. but something more generic
             state.config_space.guest_mac,
             rx_rate_limiter,
             tx_rate_limiter,
+            NetDevBackendType::Tap(state.tap_if_name.clone()),
         )?;
 
         // We trust the MMIODeviceManager::restore to pass us an MMDS data store reference if