tbs

Signed-off-by: Babis Chalios <[email protected]>

Author: bchalios

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

@@ -12,6 +12,7 @@ use std::io::{Seek, SeekFrom};
 use std::os::linux::fs::MetadataExt;
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::time::Duration;
 
 use block_io::FileEngine;
 use serde::{Deserialize, Serialize};
@@ -423,6 +424,11 @@ impl VirtioBlock {
                     }
 
                     used_any = true;
+                    if self.id == "scratch"
+                        && (request.r#type == RequestType::In || request.r#type == RequestType::Out)
+                    {
+                        std::thread::sleep(Duration::from_millis(60));
+                    }
                     request.process(&mut self.disk, head.index, mem, &self.metrics)
                 }
                 Err(err) => {

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

@@ -87,9 +87,13 @@ impl MutEventSubscriber for VirtioBlock {
             match source {
                 Self::PROCESS_ACTIVATE => self.process_activate_event(ops),
                 Self::PROCESS_QUEUE => {
-                    info!("Started processing Block queue");
+                    let tstamp = std::time::Instant::now();
                     self.process_queue_event();
-                    info!("Stopped processing Block queue");
+                    info!(
+                        "block[{}]: processed queue for {} usec",
+                        &self.id,
+                        tstamp.elapsed().as_micros()
+                    );
                 }
                 Self::PROCESS_RATE_LIMITER => self.process_rate_limiter_event(),
                 Self::PROCESS_ASYNC_COMPLETION => self.process_async_completion_event(),

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

@@ -98,7 +98,7 @@ impl MutEventSubscriber for Net {
         }
 
         if self.is_activated() {
-            info!("Started processing Net device event");
+            let tstamp = std::time::Instant::now();
             match source {
                 Self::PROCESS_ACTIVATE => self.process_activate_event(ops),
                 Self::PROCESS_VIRTQ_RX => self.process_rx_queue_event(),
@@ -111,7 +111,10 @@ impl MutEventSubscriber for Net {
                     self.metrics.event_fails.inc();
                 }
             }
-            info!("Stopped processing Net device event");
+            info!(
+                "net: processed queue for {} usec",
+                tstamp.elapsed().as_micros()
+            );
         } else {
             warn!(
                 "Net: The device is not yet activated. Spurious event received: {:?}",

tests/integration_tests/functional/test_drive_virtio.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 """Tests for guest-side operations on /drives resources."""
 
-import concurrent
+import concurrent.futures
 import os
 import time
 
@@ -409,7 +409,7 @@ def run_fio(microvm, mode, block_size, test_output_dir, fio_engine="libaio"):
         .with_arg(f"--bs={block_size}")
         .with_arg(f"--size={BLOCK_DEVICE_SIZE_MB}M")
         .with_arg(f"--ioengine={fio_engine}")
-        .with_arg("--iodepth=32")
+        .with_arg("--iodepth=256")
         # Set affinity of the entire fio process to a set of vCPUs equal in size to number of workers
         .with_arg(
             f"--cpus_allowed={','.join(str(i) for i in range(microvm.vcpus_count))}"
@@ -431,17 +431,17 @@ def run_fio(microvm, mode, block_size, test_output_dir, fio_engine="libaio"):
     prepare_microvm_for_test(microvm)
 
     with concurrent.futures.ThreadPoolExecutor() as executor:
-        executor.submit(_run_fio, microvm, test_output_dir)
-
-        for _ in range(30):
-            microvm.ssh.check_output("true")
-            time.sleep(1)
+        fio_future = executor.submit(_run_fio, microvm, cmd, test_output_dir)
+        while not fio_future.done():
+            microvm.ssh.check_output("true", timeout=1)
+        fio_future.result()
 
 
 def _run_fio(microvm, cmd, test_output_dir):
-    rc, _, stderr = microvm.ssh.run(f"cd /tmp; {cmd}")
-    assert rc == 0, stderr
+    rc, stdout, stderr = microvm.ssh.run(f"cd /tmp; {cmd}")
+    assert rc == 0
     assert stderr == ""
+    print(f"standard output: {stdout}")
 
     microvm.ssh.scp_get("/tmp/fio.json", test_output_dir)
     microvm.ssh.scp_get("/tmp/*.log", test_output_dir)
@@ -460,22 +460,22 @@ def test_greedy_block(
     fio_block_size,
     fio_engine,
     io_engine,
-    metrics,
     results_dir,
 ):
     """
     Make sure that a guest continuously using the block device
     doesn't starve a Network device
     """
     vm = microvm_factory.build(guest_kernel_acpi, rootfs, monitor_memory=False)
+    vm.jailer.extra_args.update({"no-seccomp": None})
     vm.spawn(log_level="Info", emit_metrics=False)
     vm.basic_config(vcpu_count=vcpus, mem_size_mib=1024)
     vm.add_net_iface()
 
     # Add a secondary block device for testing
     fs = drive_tools.FilesystemFile(os.path.join(vm.fsfiles, "scratch"), 4096)
-    vm.add_drive("scratch", fs.path, io_engine=io_engine)
+    vm.add_drive("scratch2", fs.path, io_engine=io_engine)
 
     vm.start()
 
-    cpu_util = run_fio(vm, fio_mode, fio_block_size, results_dir, fio_engine)
+    run_fio(vm, fio_mode, fio_block_size, results_dir, fio_engine)