refactor: only notify rx if there are processed packets

There is no point of notifing guest if there are no fully
processed packets.

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

Author: ShadowCurse

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

@@ -521,14 +521,17 @@ impl Net {
         self.read_tap().map_err(NetError::IO)
     }
 
-    fn process_rx(&mut self) -> Result<(), DeviceError> {
+    fn process_rx(&mut self) -> Result<bool, DeviceError> {
+        let mut signal_queue = false;
         // Read as many frames as possible.
         loop {
             match self.read_from_mmds_or_tap() {
                 Ok(count) => {
                     self.rx_bytes_read = count;
                     self.metrics.rx_count.inc();
-                    if !self.rate_limited_rx_single_frame() {
+                    if self.rate_limited_rx_single_frame() {
+                        signal_queue = true;
+                    } else {
                         self.rx_deferred_frame = true;
                         break;
                     }
@@ -552,9 +555,11 @@ impl Net {
             }
         }
 
-        // At this point we processed as many Rx frames as possible.
-        // We have to wake the guest if at least one descriptor chain has been used.
-        self.signal_used_queue(NetQueue::Rx)
+        // We only notify guest if there is at least one packet processed successfully.
+        if signal_queue {
+            self.signal_used_queue(NetQueue::Rx)?;
+        }
+        Ok(signal_queue)
     }
 
     // Process the deferred frame first, then continue reading from tap.
@@ -563,10 +568,12 @@ impl Net {
             self.rx_deferred_frame = false;
             // process_rx() was interrupted possibly before consuming all
             // packets in the tap; try continuing now.
-            return self.process_rx();
+            // we only signal queue if process_rx() did not already.
+            if !self.process_rx()? {
+                self.signal_used_queue(NetQueue::Rx)?;
+            }
         }
-
-        self.signal_used_queue(NetQueue::Rx)
+        Ok(())
     }
 
     fn resume_rx(&mut self) -> Result<(), DeviceError> {
@@ -651,10 +658,9 @@ impl Net {
 
         // An incoming frame for the MMDS may trigger the transmission of a new message.
         if process_rx_for_mmds {
-            self.process_rx()
-        } else {
-            Ok(())
+            self.process_rx()?;
         }
+        Ok(())
     }
 
     /// Builds the offload features we will setup on the TAP device based on the features that the
@@ -759,15 +765,14 @@ impl Net {
             return;
         }
 
-        if self.rx_deferred_frame
         // Process a deferred frame first if available. Don't read from tap again
         // until we manage to receive this deferred frame.
-        {
-            self.handle_deferred_frame()
-                .unwrap_or_else(|err| report_net_event_fail(&self.metrics, err));
-        } else {
-            self.process_rx()
-                .unwrap_or_else(|err| report_net_event_fail(&self.metrics, err));
+        if self.rx_deferred_frame {
+            if let Err(err) = self.handle_deferred_frame() {
+                report_net_event_fail(&self.metrics, err);
+            }
+        } else if let Err(err) = self.process_rx() {
+            report_net_event_fail(&self.metrics, err);
         }
     }
 

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

@@ -501,7 +501,7 @@ pub mod test {
             assert!(self.net().rx_deferred_frame);
             // Check that the descriptor chain has been discarded.
             assert_eq!(self.rxq.used.idx.get(), used_idx + 1);
-            assert!(&self.net().irq_trigger.has_pending_irq(IrqType::Vring));
+            assert!(!self.net().irq_trigger.has_pending_irq(IrqType::Vring));
 
             frame
         }