fix(block): only notify guest once

Currently block device has a guest notification logic
inside it's request processing loop. This can create a
situation when guest can continuously add more requests to the
queue, making the whole request processing loop arbitrary long.
This is an issue, since it block any other IO from being processed.

The solution is to simply notify guest one time, after all current
requests are processed.

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

Author: ShadowCurse

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

@@ -384,24 +384,6 @@ impl VirtioBlock {
         }
     }
 
-    fn add_used_descriptor(
-        queue: &mut Queue,
-        index: u16,
-        len: u32,
-        irq_trigger: &IrqTrigger,
-        block_metrics: &BlockDeviceMetrics,
-    ) {
-        queue.add_used(index, len).unwrap_or_else(|err| {
-            error!("Failed to add available descriptor head {}: {}", index, err)
-        });
-
-        if queue.prepare_kick() {
-            irq_trigger.trigger_irq(IrqType::Vring).unwrap_or_else(|_| {
-                block_metrics.event_fails.inc();
-            });
-        }
-    }
-
     /// Device specific function for peaking inside a queue and processing descriptors.
     pub fn process_queue(&mut self, queue_index: usize) -> Result<(), InvalidAvailIdx> {
         // This is safe since we checked in the event handler that the device is activated.
@@ -422,7 +404,6 @@ impl VirtioBlock {
                         break;
                     }
 
-                    used_any = true;
                     request.process(&mut self.disk, head.index, mem, &self.metrics)
                 }
                 Err(err) => {
@@ -443,17 +424,27 @@ impl VirtioBlock {
                     break;
                 }
                 ProcessingResult::Executed(finished) => {
-                    Self::add_used_descriptor(
-                        queue,
-                        head.index,
-                        finished.num_bytes_to_mem,
-                        &self.irq_trigger,
-                        &self.metrics,
-                    );
+                    used_any = true;
+                    queue
+                        .add_used(head.index, finished.num_bytes_to_mem)
+                        .unwrap_or_else(|err| {
+                            error!(
+                                "Failed to add available descriptor head {}: {}",
+                                head.index, err
+                            )
+                        });
                 }
             }
         }
 
+        if used_any && queue.prepare_kick() {
+            self.irq_trigger
+                .trigger_irq(IrqType::Vring)
+                .unwrap_or_else(|_| {
+                    self.metrics.event_fails.inc();
+                });
+        }
+
         if let FileEngine::Async(ref mut engine) = self.disk.file_engine {
             if let Err(err) = engine.kick_submission_queue() {
                 error!("BlockError submitting pending block requests: {:?}", err);
@@ -495,17 +486,25 @@ impl VirtioBlock {
                         ),
                     };
                     let finished = pending.finish(mem, res, &self.metrics);
-
-                    Self::add_used_descriptor(
-                        queue,
-                        finished.desc_idx,
-                        finished.num_bytes_to_mem,
-                        &self.irq_trigger,
-                        &self.metrics,
-                    );
+                    queue
+                        .add_used(finished.desc_idx, finished.num_bytes_to_mem)
+                        .unwrap_or_else(|err| {
+                            error!(
+                                "Failed to add available descriptor head {}: {}",
+                                finished.desc_idx, err
+                            )
+                        });
                 }
             }
         }
+
+        if queue.prepare_kick() {
+            self.irq_trigger
+                .trigger_irq(IrqType::Vring)
+                .unwrap_or_else(|_| {
+                    self.metrics.event_fails.inc();
+                });
+        }
     }
 
     pub fn process_async_completion_event(&mut self) {