virtio: add vm level flush tests

This adds python tests to verify the correct operation
of flush. The features file in /sys/block/<drive>/device/features
is checked to ensure that it is correct with respect to the
optional 'want_flush' drive setting. Metrics also verify that
by default, no flushes are received. Only when 'want_flush' is
true should the 'flush_count' block metric increase.

Signed-off-by: Peter Lawthers [email protected]

Author: pclesr

tests/framework/microvm.py

@@ -558,14 +558,16 @@ def add_drive(
             root_device=False,
             is_read_only=False,
             partuuid=None,
+            want_flush=False,
     ):
         """Add a block device."""
         response = self.drive.put(
             drive_id=drive_id,
             path_on_host=self.create_jailed_resource(file_path),
             is_root_device=root_device,
             is_read_only=is_read_only,
-            partuuid=partuuid
+            partuuid=partuuid,
+            want_flush=want_flush
         )
         assert self.api_session.is_status_no_content(response.status_code)
 

tests/framework/resources.py

@@ -142,7 +142,8 @@ def create_json(
             is_root_device=None,
             partuuid=None,
             is_read_only=None,
-            rate_limiter=None):
+            rate_limiter=None,
+            want_flush=None):
         """Compose the json associated to this type of API request."""
         datax = {}
 
@@ -164,6 +165,9 @@ def create_json(
         if rate_limiter is not None:
             datax['rate_limiter'] = rate_limiter
 
+        if want_flush is not None:
+            datax['want_flush'] = want_flush
+
         return datax
 
 

tests/integration_tests/functional/test_drives.py

@@ -10,6 +10,7 @@
 
 import host_tools.drive as drive_tools
 import host_tools.network as net_tools  # pylint: disable=import-error
+import host_tools.logging as log_tools  # metrics
 
 
 def test_rescan_file(test_microvm_with_ssh, network_config):
@@ -329,6 +330,108 @@ def test_patch_drive(test_microvm_with_ssh, network_config):
     assert stdout.readline().strip() == size_bytes_str
 
 
+def test_rootfs_rw_noflush(test_microvm_with_ssh, network_config):
+    """Verify default rootfs does not invoke flush."""
+    test_microvm = test_microvm_with_ssh
+    test_microvm.spawn()
+
+    # Set up the microVM with 1 vCPUs, 256 MiB of RAM, no network ifaces and
+    # a root file system with the rw permission. The network interfaces is
+    # added after we get a unique MAC and IP.
+    test_microvm.basic_config(
+        vcpu_count=1,
+        add_root_device=False
+    )
+
+    _tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
+
+    # Add the root block device
+    test_microvm.add_drive(
+        'rootfs',
+        test_microvm.rootfs_file,
+        root_device=True,
+    )
+
+    # Configure metrics, to get later the `flush_count`.
+    metrics_fifo_path = os.path.join(test_microvm.path, 'metrics_fifo')
+    metrics_fifo = log_tools.Fifo(metrics_fifo_path)
+    response = test_microvm.metrics.put(
+        metrics_path=test_microvm.create_jailed_resource(metrics_fifo.path)
+    )
+    assert test_microvm.api_session.is_status_no_content(response.status_code)
+
+    test_microvm.start()
+
+    # From spec: pub const VIRTIO_F_VERSION_1: u32 = 32;
+    lo32 = "00000000000000000000000000000000"
+    hi32 = "10000000000000000000000000000000"
+    default_features = lo32 + hi32
+
+    ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
+    cmd = "cat /sys/block/vda/device/features"
+    _, stdout, stderr = ssh_connection.execute_command(cmd)
+    assert stderr.read() == ''
+    assert stdout.readline().strip() == default_features
+
+    # Verify no flush commands were generated during boot. By
+    # default, on a RW device with flush enabled, there will be
+    # +- six virtio flush commands
+    fc_metrics = test_microvm.flush_metrics(metrics_fifo)
+    assert fc_metrics['block']['flush_count'] == 0
+
+
+def test_rootfs_rw_flush(test_microvm_with_ssh, network_config):
+    """Verify rootfs with flush does invoke flush."""
+    test_microvm = test_microvm_with_ssh
+    test_microvm.spawn()
+
+    # Set up the microVM with 1 vCPUs, 256 MiB of RAM, no network ifaces and
+    # a root file system with the rw permission. The network interfaces is
+    # added after we get a unique MAC and IP.
+    test_microvm.basic_config(
+        vcpu_count=1,
+        add_root_device=False
+    )
+
+    _tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
+
+    # Add the root block device
+    test_microvm.add_drive(
+        'rootfs',
+        test_microvm.rootfs_file,
+        root_device=True,
+        want_flush=True,
+    )
+
+    # Configure metrics, to get later the `flush_count`.
+    metrics_fifo_path = os.path.join(test_microvm.path, 'metrics_fifo')
+    metrics_fifo = log_tools.Fifo(metrics_fifo_path)
+    response = test_microvm.metrics.put(
+        metrics_path=test_microvm.create_jailed_resource(metrics_fifo.path)
+    )
+    assert test_microvm.api_session.is_status_no_content(response.status_code)
+
+    test_microvm.start()
+
+    # From spec: pub const VIRTIO_F_VERSION_1: u32 = 32;
+    #            pub const VIRTIO_BLK_F_FLUSH: u32 = 9;
+    lo32 = "00000000010000000000000000000000"
+    hi32 = "10000000000000000000000000000000"
+    default_features = lo32 + hi32
+
+    ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
+    cmd = "cat /sys/block/vda/device/features"
+    _, stdout, stderr = ssh_connection.execute_command(cmd)
+    assert stderr.read() == ''
+    assert stdout.readline().strip() == default_features
+
+    # Verify no flush commands were generated during boot. By
+    # default, on a RW device with flush enabled, there will be
+    # +- six virtio flush commands
+    fc_metrics = test_microvm.flush_metrics(metrics_fifo)
+    assert fc_metrics['block']['flush_count'] > 0
+
+
 def _check_block_size(ssh_connection, dev_path, size):
     _, stdout, stderr = ssh_connection.execute_command(
         'blockdev --getsize64 {}'.format(dev_path)