Merge branch 'master' into rust-vers-bump

Author: dianpopa

src/vmm/src/vstate/vcpu/mod.rs

@@ -21,6 +21,7 @@ use crate::{
     vmm_config::machine_config::CpuFeaturesTemplate, vstate::vm::Vm, FC_EXIT_CODE_GENERIC_ERROR,
     FC_EXIT_CODE_OK,
 };
+use kvm_bindings::{KVM_SYSTEM_EVENT_RESET, KVM_SYSTEM_EVENT_SHUTDOWN};
 use kvm_ioctls::VcpuExit;
 use logger::{error, info, IncMetric, METRICS};
 use seccomp::{BpfProgram, SeccompFilter};
@@ -473,6 +474,26 @@ impl Vcpu {
                         VcpuExit::InternalError
                     )))
                 }
+                VcpuExit::SystemEvent(event_type, event_flags) => match event_type {
+                    KVM_SYSTEM_EVENT_RESET | KVM_SYSTEM_EVENT_SHUTDOWN => {
+                        info!(
+                            "Received KVM_SYSTEM_EVENT: type: {}, event: {}",
+                            event_type, event_flags
+                        );
+                        Ok(VcpuEmulation::Stopped)
+                    }
+                    _ => {
+                        METRICS.vcpu.failures.inc();
+                        error!(
+                            "Received KVM_SYSTEM_EVENT signal type: {}, flag: {}",
+                            event_type, event_flags
+                        );
+                        Err(Error::FaultyKvmExit(format!(
+                            "{:?}",
+                            VcpuExit::SystemEvent(event_type, event_flags)
+                        )))
+                    }
+                },
                 arch_specific_reason => {
                     // run specific architecture emulation.
                     self.kvm_vcpu.run_arch_emulation(arch_specific_reason)

tests/framework/artifacts.py

@@ -238,8 +238,9 @@ def copy(self, vm_root_folder):
 
         return Snapshot(dst_mem_path,
                         dst_state_file,
-                        disk_paths,
-                        dst_ssh_key)
+                        disks=disk_paths,
+                        net_ifaces=None,
+                        ssh_key=dst_ssh_key)
 
 
 class DiskArtifact(Artifact):
@@ -433,7 +434,7 @@ class SnapshotType(Enum):
 class Snapshot:
     """Manages Firecracker snapshots."""
 
-    def __init__(self, mem, vmstate, disks, ssh_key):
+    def __init__(self, mem, vmstate, disks, net_ifaces, ssh_key):
         """Initialize mem, vmstate, disks, key."""
         assert mem is not None
         assert vmstate is not None
@@ -443,6 +444,7 @@ def __init__(self, mem, vmstate, disks, ssh_key):
         self._vmstate = vmstate
         self._disks = disks
         self._ssh_key = ssh_key
+        self._net_ifaces = net_ifaces
 
     def rebase_snapshot(self, base):
         """Rebases current incremental snapshot onto a specified base layer."""
@@ -468,3 +470,58 @@ def disks(self):
     def ssh_key(self):
         """Return the ssh key file path."""
         return self._ssh_key
+
+    @property
+    def net_ifaces(self):
+        """Return the list of net interface configs."""
+        return self._net_ifaces
+
+
+# Default configuration values for network interfaces.
+DEFAULT_HOST_IP = "192.168.0.1"
+DEFAULT_GUEST_IP = "192.168.0.2"
+DEFAULT_TAP_NAME = "tap0"
+DEFAULT_DEV_NAME = "eth0"
+DEFAULT_NETMASK = 30
+
+
+class NetIfaceConfig:
+    """Defines a network interface configuration."""
+
+    def __init__(self,
+                 host_ip=DEFAULT_HOST_IP,
+                 guest_ip=DEFAULT_GUEST_IP,
+                 tap_name=DEFAULT_TAP_NAME,
+                 dev_name=DEFAULT_DEV_NAME,
+                 netmask=DEFAULT_NETMASK):
+        """Initialize object."""
+        self._host_ip = host_ip
+        self._guest_ip = guest_ip
+        self._tap_name = tap_name
+        self._dev_name = dev_name
+        self._netmask = netmask
+
+    @property
+    def host_ip(self):
+        """Return the host IP."""
+        return self._host_ip
+
+    @property
+    def guest_ip(self):
+        """Return the guest IP."""
+        return self._guest_ip
+
+    @property
+    def tap_name(self):
+        """Return the tap device name."""
+        return self._tap_name
+
+    @property
+    def dev_name(self):
+        """Return the guest device name."""
+        return self._dev_name
+
+    @property
+    def netmask(self):
+        """Return the netmask."""
+        return self._netmask

tests/framework/builder.py

@@ -7,19 +7,14 @@
 import tempfile
 from pathlib import Path
 from conftest import init_microvm
-from framework.artifacts import Artifact, DiskArtifact, Snapshot, SnapshotType
+from framework.artifacts import (
+    Artifact, DiskArtifact, Snapshot, SnapshotType, NetIfaceConfig
+)
 import framework.utils as utils
 import host_tools.logging as log_tools
 import host_tools.network as net_tools
 
 
-DEFAULT_HOST_IP = "192.168.0.1"
-DEFAULT_GUEST_IP = "192.168.0.2"
-DEFAULT_TAP_NAME = "tap0"
-DEFAULT_DEV_NAME = "eth0"
-DEFAULT_NETMASK = 30
-
-
 class MicrovmBuilder:
     """Build fresh microvms or restore from snapshot."""
 
@@ -55,7 +50,7 @@ def build(self,
               disks: [DiskArtifact],
               ssh_key: Artifact,
               config: Artifact,
-              network_config: net_tools.UniqueIPv4Generator = None,
+              net_ifaces=None,
               enable_diff_snapshots=False,
               cpu_template=None):
         """Build a fresh microvm."""
@@ -73,25 +68,27 @@ def build(self,
         ssh_key.download(self.root_path)
         vm.ssh_config['ssh_key_path'] = ssh_key.local_path()
         os.chmod(vm.ssh_config['ssh_key_path'], 0o400)
-        if network_config:
-            (host_ip, guest_ip) = network_config.get_next_available_ips(2)
-        else:
-            host_ip, guest_ip = DEFAULT_HOST_IP, DEFAULT_GUEST_IP
-        vm.create_tap_and_ssh_config(host_ip=host_ip,
-                                     guest_ip=guest_ip,
-                                     netmask_len=DEFAULT_NETMASK,
-                                     tapname=DEFAULT_TAP_NAME)
-
-        # TODO: propper network configuraiton with artifacts.
-        guest_mac = net_tools.mac_from_ip(guest_ip)
-        response = vm.network.put(
-            iface_id=DEFAULT_DEV_NAME,
-            host_dev_name=DEFAULT_TAP_NAME,
-            guest_mac=guest_mac,
-            allow_mmds_requests=True,
-        )
 
-        assert vm.api_session.is_status_no_content(response.status_code)
+        # Provide a default network configuration.
+        if net_ifaces is None or len(net_ifaces) == 0:
+            ifaces = [NetIfaceConfig()]
+        else:
+            ifaces = net_ifaces
+
+        # Configure network interfaces using artifacts.
+        for iface in ifaces:
+            vm.create_tap_and_ssh_config(host_ip=iface.host_ip,
+                                         guest_ip=iface.guest_ip,
+                                         netmask_len=iface.netmask,
+                                         tapname=iface.tap_name)
+            guest_mac = net_tools.mac_from_ip(iface.guest_ip)
+            response = vm.network.put(
+                iface_id=iface.dev_name,
+                host_dev_name=iface.tap_name,
+                guest_mac=guest_mac,
+                allow_mmds_requests=True,
+            )
+            assert vm.api_session.is_status_no_content(response.status_code)
 
         with open(config.local_path()) as microvm_config_file:
             microvm_config = json.load(microvm_config_file)
@@ -144,16 +141,16 @@ def build_from_snapshot(self,
             _jailed_disks.append(vm.create_jailed_resource(disk))
         vm.ssh_config['ssh_key_path'] = snapshot.ssh_key
 
-        vm.create_tap_and_ssh_config(host_ip=DEFAULT_HOST_IP,
-                                     guest_ip=DEFAULT_GUEST_IP,
-                                     netmask_len=DEFAULT_NETMASK,
-                                     tapname=DEFAULT_TAP_NAME)
-
+        # Create network interfaces.
+        for iface in snapshot.net_ifaces:
+            vm.create_tap_and_ssh_config(host_ip=iface.host_ip,
+                                         guest_ip=iface.guest_ip,
+                                         netmask_len=iface.netmask,
+                                         tapname=iface.tap_name)
         response = vm.snapshot.load(mem_file_path=jailed_mem,
                                     snapshot_path=jailed_vmstate,
                                     diff=enable_diff_snapshots,
                                     resume=resume)
-
         assert vm.api_session.is_status_no_content(response.status_code)
 
         # Reset root path so next microvm is built some place else.
@@ -192,7 +189,8 @@ def create(self,
                snapshot_type: SnapshotType = SnapshotType.FULL,
                target_version: str = None,
                mem_file_name: str = "vm.mem",
-               snapshot_name: str = "vm.vmstate"):
+               snapshot_name: str = "vm.vmstate",
+               net_ifaces=None):
         """Create a Snapshot object from a microvm and artifacts."""
         # Disable API timeout as the APIs for snapshot related procedures
         # take longer.
@@ -215,4 +213,5 @@ def create(self,
                         # in S3. This should be done in a PR where we add tests
                         # that resume from S3 snapshot artifacts.
                         disks=disks,
+                        net_ifaces=net_ifaces or [NetIfaceConfig()],
                         ssh_key=ssh_key_copy.local_path())

tests/framework/microvms.py

@@ -55,7 +55,8 @@ class VMBase:
     @classmethod
     def from_artifacts(cls, bin_cloner_path, config,
                        kernel, disks, cpu_template, start=False,
-                       fc_binary=None, jailer_binary=None):
+                       fc_binary=None, jailer_binary=None,
+                       net_ifaces=None, enable_diff_snapshots=False):
         """Spawns a new Firecracker and applies specified config."""
         artifacts = ArtifactCollection(_test_images_s3_bucket())
         # Pick the first artifact in the set.
@@ -82,7 +83,9 @@ def from_artifacts(cls, bin_cloner_path, config,
                                   disks=attached_disks,
                                   ssh_key=ssh_key,
                                   config=config,
-                                  cpu_template=cpu_template)
+                                  cpu_template=cpu_template,
+                                  net_ifaces=net_ifaces,
+                                  enable_diff_snapshots=enable_diff_snapshots)
 
         if start:
             basevm.start()
@@ -100,7 +103,8 @@ class VMNano(VMBase):
 
     @classmethod
     def spawn(cls, bin_cloner_path, start=False,
-              fc_binary=None, jailer_binary=None):
+              fc_binary=None, jailer_binary=None,
+              net_ifaces=None, diff_snapshots=False):
         """Spawns and optionally starts the vm."""
         return VMBase.from_artifacts(bin_cloner_path,
                                      "2vcpu_256mb",
@@ -109,15 +113,18 @@ def spawn(cls, bin_cloner_path, start=False,
                                      None,
                                      start,
                                      fc_binary,
-                                     jailer_binary)
+                                     jailer_binary,
+                                     net_ifaces=net_ifaces,
+                                     enable_diff_snapshots=diff_snapshots)
 
 
 class VMMicro(VMBase):
     """Create VMs with 2vCPUs and 512 MB RAM."""
 
     @classmethod
     def spawn(cls, bin_cloner_path, start=False,
-              fc_binary=None, jailer_binary=None):
+              fc_binary=None, jailer_binary=None,
+              net_ifaces=None, diff_snapshots=False):
         """Spawns and optionally starts the vm."""
         return VMBase.from_artifacts(bin_cloner_path,
                                      "2vcpu_512mb",
@@ -126,4 +133,6 @@ def spawn(cls, bin_cloner_path, start=False,
                                      None,
                                      start,
                                      fc_binary,
-                                     jailer_binary)
+                                     jailer_binary,
+                                     net_ifaces=net_ifaces,
+                                     enable_diff_snapshots=diff_snapshots)

tests/integration_tests/build/test_coverage.py

@@ -23,7 +23,7 @@
 # this contains the frequency while on AMD it does not.
 # Checkout the cpuid crate. In the future other
 # differences may appear.
-COVERAGE_DICT = {"Intel": 85.35, "AMD": 84.63, "ARM": 82.81}
+COVERAGE_DICT = {"Intel": 85.25, "AMD": 84.50, "ARM": 82.72}
 PROC_MODEL = proc.proc_type()
 
 COVERAGE_MAX_DELTA = 0.05

tests/integration_tests/functional/test_balloon.py

@@ -120,29 +120,8 @@ def copy_util_to_rootfs(rootfs_path, util):
     subprocess.check_call("rmdir tmpfs", shell=True)
 
 
-# pylint: disable=C0103
-def test_rss_memory_lower(test_microvm_with_ssh_and_balloon, network_config):
+def _test_rss_memory_lower(test_microvm):
     """Check inflating the balloon makes guest use less rss memory."""
-    test_microvm = test_microvm_with_ssh_and_balloon
-    test_microvm.spawn()
-    test_microvm.basic_config()
-    _tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
-    test_microvm.ssh_config['ssh_key_path'] = os.path.join(
-        test_microvm.fsfiles,
-        'debian.rootfs.id_rsa'
-    )
-
-    # Add a memory balloon.
-    response = test_microvm.balloon.put(
-        amount_mb=0,
-        deflate_on_oom=True,
-        stats_polling_interval_s=0
-    )
-    assert test_microvm.api_session.is_status_no_content(response.status_code)
-
-    # Start the microvm.
-    test_microvm.start()
-
     # Get the firecracker pid, and open an ssh connection.
     firecracker_pid = test_microvm.jailer_clone_pid
     ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
@@ -172,6 +151,32 @@ def test_rss_memory_lower(test_microvm_with_ssh_and_balloon, network_config):
     assert balloon_rss - init_rss <= 15000
 
 
+# pylint: disable=C0103
+def test_rss_memory_lower(test_microvm_with_ssh_and_balloon, network_config):
+    """Check inflating the balloon makes guest use less rss memory."""
+    test_microvm = test_microvm_with_ssh_and_balloon
+    test_microvm.spawn()
+    test_microvm.basic_config()
+    _tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
+    test_microvm.ssh_config['ssh_key_path'] = os.path.join(
+        test_microvm.fsfiles,
+        'debian.rootfs.id_rsa'
+    )
+
+    # Add a memory balloon.
+    response = test_microvm.balloon.put(
+        amount_mb=0,
+        deflate_on_oom=True,
+        stats_polling_interval_s=0
+    )
+    assert test_microvm.api_session.is_status_no_content(response.status_code)
+
+    # Start the microvm.
+    test_microvm.start()
+
+    _test_rss_memory_lower(test_microvm)
+
+
 # pylint: disable=C0103
 def test_inflate_reduces_free(test_microvm_with_ssh_and_balloon,
                               network_config):

tests/integration_tests/functional/test_shut_down.py

@@ -4,6 +4,7 @@
 import os
 import time
 import json
+import platform
 
 import framework.utils as utils
 
@@ -69,5 +70,10 @@ def test_reboot(test_microvm_with_ssh, network_config):
     lines = metrics_fifo.sequential_reader(100)
     assert len(lines) == 1
 
+    if platform.machine() != "x86_64":
+        log_data = test_microvm.log_data
+        assert "Received KVM_SYSTEM_EVENT: type: 2, event: 0" in log_data
+        assert "Vmm is stopping." in log_data
+
     # Make sure that the FC process was not killed by a seccomp fault
     assert json.loads(lines[0])["seccomp"]["num_faults"] == 0