Easy dependency switch if only preload is in chain

Fixes: QubesOS/qubes-issues#10227
For: QubesOS/qubes-issues#1512

Author: ben-grande

qubes/api/internal.py

@@ -267,7 +267,7 @@ async def suspend_pre(self):
 
         preload_templates = qubes.vm.dispvm.get_preload_templates(self.app)
         for qube in preload_templates:
-            qube.remove_preload_excess(0)
+            qube.remove_preload_excess(0, reason="system wants to suspend")
 
         # first keep track of VMs which were paused before suspending
         previously_paused = [

qubes/app.py

@@ -1632,6 +1632,8 @@ def _domain_event_callback(self, _conn, domain, event, _detail, _opaque):
     @qubes.events.handler("domain-pre-delete")
     def on_domain_pre_deleted(self, event, vm):
         # pylint: disable=unused-argument
+        preloads = set()
+        dependencies = []
         for obj in itertools.chain(self.domains, (self,)):
             if obj is vm:
                 # allow removed VM to reference itself
@@ -1642,18 +1644,32 @@ def on_domain_pre_deleted(self, event, vm):
                         isinstance(prop, qubes.vm.VMProperty)
                         and getattr(obj, prop.__name__) == vm
                     ):
-                        self.log.error(
-                            "Cannot remove %s, used by %s.%s",
-                            vm,
-                            obj,
-                            prop.__name__,
-                        )
-                        raise qubes.exc.QubesVMInUseError(
-                            vm,
-                            "Domain is in use: {!r};"
-                            "see 'journalctl -u qubesd -e' in dom0 for "
-                            "details".format(vm.name),
-                        )
+                        if getattr(obj, "is_preload", False) and (
+                            prop.__name__ == "template"
+                            or (
+                                prop.__name__ == "default_dispvm"
+                                and getattr(obj, "template", None) == vm
+                            )
+                        ):
+                            preloads.add(obj.name)
+                            continue
+                        if isinstance(obj, qubes.app.Qubes):
+                            dependencies.append(('"GLOBAL"', prop.__name__))
+                        elif not obj.property_is_default(prop):
+                            dependencies.append((obj.name, prop.__name__))
+        if dependencies:
+            self.log.error(
+                "Cannot remove %s as it is used by %s",
+                vm,
+                ", ".join(
+                    ":".join(str(i) for i in tup) for tup in dependencies
+                ),
+            )
+            raise qubes.exc.QubesVMInUseError(
+                vm,
+                "Domain is in use: {!r};  see 'journalctl -u qubesd -e' in dom0"
+                " for details".format(vm.name),
+            )
         if isinstance(vm, qubes.vm.qubesvm.QubesVM):
             assignments = vm.get_provided_assignments()
         else:
@@ -1664,6 +1680,9 @@ def on_domain_pre_deleted(self, event, vm):
                 vm, "VM has devices assigned to other VMs: " + desc
             )
 
+        if preloads:
+            vm.remove_preload_excess(0, reason="domain will be deleted")
+
     @qubes.events.handler("domain-delete")
     def on_domain_deleted(self, event, vm):
         # pylint: disable=unused-argument

qubes/ext/audio.py

@@ -69,10 +69,12 @@ def set_tag_and_qubesdb_entry(self, subject, event, newvalue=None):
     @qubes.ext.handler("domain-pre-shutdown")
     def on_domain_pre_shutdown(self, vm, event, **kwargs):
         attached_vms = [
-            domain for domain in self.attached_vms(vm) if domain.is_running()
+            domain
+            for domain in self.attached_vms(vm)
+            if domain.is_running() and not getattr(domain, "is_preload", False)
         ]
         if attached_vms and not kwargs.get("force", False):
-            raise qubes.exc.QubesVMError(
+            raise qubes.exc.QubesVMInUseError(
                 self,
                 "There are running VMs using this VM as AudioVM: "
                 "{}".format(", ".join(vm.name for vm in attached_vms)),

qubes/tests/api_internal.py

@@ -44,6 +44,7 @@ def setUp(self):
         self.app = mock.NonCallableMock()
         self.dom0 = mock.NonCallableMock(spec=qubes.vm.adminvm.AdminVM)
         self.dom0.name = "dom0"
+        self.dom0.klass = "AdminVM"
         self.dom0.features = {}
         self.domains = {
             "dom0": self.dom0,
@@ -88,17 +89,24 @@ def call_mgmt_func(self, method, arg=b"", payload=b""):
     def test_000_suspend_pre(self):
         running_vm = self.create_mockvm(features={"qrexec": True})
         running_vm.is_running.return_value = True
+        running_vm.klass = "AppVM"
 
-        not_running_vm = self.create_mockvm(features={"qrexec": True})
+        not_running_vm = self.create_mockvm(
+            features={"qrexec": True, "preload-dispvm-max": "1"}
+        )
         not_running_vm.is_running.return_value = False
+        not_running_vm.template_for_dispvms = True
+        not_running_vm.klass = "AppVM"
 
         no_qrexec_vm = self.create_mockvm()
         no_qrexec_vm.is_running.return_value = True
+        no_qrexec_vm.klass = "AppVM"
 
         paused_vm = self.create_mockvm(features={"qrexec": True})
         paused_vm.is_running.return_value = True
         paused_vm.get_power_state.return_value = "Paused"
         paused_vm.name = "SleepingBeauty"
+        paused_vm.klass = "AppVM"
 
         self.domains.update(
             {
@@ -113,8 +121,11 @@ def test_000_suspend_pre(self):
             qubes.api.internal,
             "PREVIOUSLY_PAUSED",
             "/tmp/qubes-previously-paused.tmp",
-        ):
+        ), mock.patch.object(
+            not_running_vm, "remove_preload_excess"
+        ) as mock_remove:
             ret = self.call_mgmt_func(b"internal.SuspendPre")
+            mock_remove.assert_called_once_with(0, reason=mock.ANY)
         self.assertIsNone(ret)
         self.assertFalse(self.dom0.called)
 

qubes/tests/app.py

@@ -1096,6 +1096,46 @@ def test_205_remove_appvm_dispvm(self):
             with self.assertRaises(qubes.exc.QubesVMInUseError):
                 del self.app.domains[appvm]
 
+    def test_205_remove_appvm_dispvm_preload(self):
+        appvm = self.app.add_new_vm(
+            "AppVM",
+            name="test-appvm",
+            template=self.template,
+            template_for_dispvms=True,
+            label="red",
+        )
+        dispvm = self.app.add_new_vm(
+            "DispVM", name="test-dispvm", template=appvm, label="red"
+        )
+        dispvm_alt = self.app.add_new_vm(
+            "DispVM", name="test-dispvm-alt", template=appvm, label="red"
+        )
+        with mock.patch.object(self.app, "vmm"):
+            with self.assertRaises(qubes.exc.QubesVMInUseError):
+                del self.app.domains[appvm]
+
+        with mock.patch.object(self.app, "vmm"):
+            with mock.patch.object(appvm, "fire_event_async"):
+                appvm.features["preload-dispvm-max"] = "1"
+                appvm.features["preload-dispvm"] = str(dispvm.name)
+                with self.assertRaises(qubes.exc.QubesVMInUseError):
+                    del self.app.domains[appvm]
+
+        with mock.patch.object(self.app, "vmm"):
+            with (
+                mock.patch.object(appvm, "fire_event_async"),
+                mock.patch.object(
+                    appvm, "remove_preload_excess"
+                ) as mock_remove,
+            ):
+                appvm.features["preload-dispvm-max"] = "2"
+                appvm.features["preload-dispvm"] = dispvm.name
+                appvm.features["preload-dispvm"] = (
+                    dispvm.name + " " + dispvm_alt.name
+                )
+                del self.app.domains[appvm]
+                mock_remove.assert_called_with(0, reason=mock.ANY)
+
     def test_206_remove_attached(self):
         # See also qubes.tests.api_admin.
         vm = self.app.add_new_vm(

qubes/tests/ext.py

@@ -21,6 +21,7 @@
 import os
 import unittest.mock
 
+import qubes.ext.audio
 import qubes.ext.core_features
 import qubes.ext.custom_persist
 import qubes.ext.services
@@ -2579,3 +2580,58 @@ def test_015_feature_set_path_with_colon_without_options(self):
         self.vm.untrusted_qdb.write.assert_called_with(
             "/persist/test", "/var/test:dir:with:colon"
         )
+
+
+class TC_60_Audio(qubes.tests.QubesTestCase):
+    def setUp(self):
+        super().setUp()
+        self.ext = qubes.ext.audio.AUDIO()
+        self.audiovm = mock.MagicMock()
+        self.audiovm.name = "sys-audio"
+        self.client = mock.MagicMock()
+        self.client.name = "client"
+        self.client_alt = mock.MagicMock()
+        self.client_alt.name = "client"
+
+    def test_000_shutdown(self):
+        self.ext.on_domain_pre_shutdown(
+            self.audiovm,
+            "domain-pre-shutdown",
+        )
+
+    def test_000_shutdown_used(self):
+        with unittest.mock.patch.object(
+            self.ext, "attached_vms", return_value=[self.client]
+        ), unittest.mock.patch.object(
+            self.client, "is_running", return_value=True
+        ):
+            self.client.is_preload = False
+            with self.assertRaises(qubes.exc.QubesVMInUseError):
+                self.ext.on_domain_pre_shutdown(
+                    self.audiovm,
+                    "domain-pre-shutdown",
+                )
+
+            self.client.is_preload = True
+            self.ext.on_domain_pre_shutdown(
+                self.audiovm,
+                "domain-pre-shutdown",
+            )
+
+    def test_000_shutdown_used_by_some(self):
+        with unittest.mock.patch.object(
+            self.ext,
+            "attached_vms",
+            return_value=[self.client, self.client_alt],
+        ), unittest.mock.patch.object(
+            self.client, "is_running", return_value=True
+        ), unittest.mock.patch.object(
+            self.client_alt, "is_running", return_value=True
+        ):
+            self.client.is_preload = False
+            self.client_alt.is_preload = True
+            with self.assertRaises(qubes.exc.QubesVMInUseError):
+                self.ext.on_domain_pre_shutdown(
+                    self.audiovm,
+                    "domain-pre-shutdown",
+                )