ai code

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

Author: aerosouund

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

@@ -167,40 +167,39 @@ impl NetDevBackend for PasstBackend {
     fn read_iovec(&mut self, buffer: &mut [libc::iovec]) -> Result<usize, IoError> {
         let iov = buffer.as_mut_ptr();
 
-        // offset the buffer by 12 to leave room for virtio header
+        // the frame data goes into guest buffer offset by vnet_hdr_len to leave room for virtio header
         let data_iov = libc::iovec {
             iov_base: unsafe { ((*iov).iov_base as *mut u8).add(vnet_hdr_len()) as *mut _ },
             iov_len: unsafe { (*iov).iov_len - vnet_hdr_len() },
         };
 
-        // ammar: we are saying this is a "Socket" backend. not a passt backend. so should we really
-        // be having passt specific handling ? also on some level how well do we even understand passt ?
-        // is using it as in the test the standard way even ?
-        // create a 4 byte buffer, read the size that passt prepends into the packet and discard those
-        // bytes. we only care about the data packets
+        // wire format from passt is: [vnet header (12)][length (4)][ethernet frame]
+        // read vnet header and length prefix into throwaway buffers
+        let mut vnet_buf = [0u8; 12];
         let mut len_buf = [0u8; 4];
-        let ret = unsafe {
-            libc::read(
-                self.fd.as_raw_fd(),
-                len_buf.as_mut_ptr() as *mut core::ffi::c_void,
-                4,
-            )
-        };
-        if ret == -1 {
-            return Err(IoError::last_os_error());
-        }
 
-        let _frame_len = u32::from_be(u32::from_ne_bytes(len_buf));
+        let vnet_iov = libc::iovec {
+            iov_base: vnet_buf.as_mut_ptr() as *mut _,
+            iov_len: vnet_hdr_len(),
+        };
+        let len_iov = libc::iovec {
+            iov_base: len_buf.as_mut_ptr() as *mut _,
+            iov_len: 4,
+        };
 
-        let ret = unsafe { libc::readv(self.fd.as_raw_fd(), &data_iov, 1) };
+        // read vnet header + length prefix + ethernet frame in one syscall
+        let mut iovs = [vnet_iov, len_iov, data_iov];
+        let ret = unsafe { libc::readv(self.fd.as_raw_fd(), iovs.as_mut_ptr(), 3) };
         if ret == -1 {
             return Err(IoError::last_os_error());
         }
 
-        // zero out the virtio header at the start
+        // zero out the virtio header region at the start of the guest buffer
         unsafe { std::ptr::write_bytes((*iov).iov_base as *mut u8, 0, vnet_hdr_len()) };
 
-        Ok(usize::try_from(ret).unwrap())
+        // subtract the vnet header and length prefix bytes from the returned size
+        // since the caller only cares about the ethernet frame size
+        Ok(usize::try_from(ret).unwrap() - vnet_hdr_len() - 4)
     }
 
     fn write_iovec(&mut self, buffer: &IoVecBuffer) -> Result<usize, IoError> {