Skip startup tasks when preload is requested

Waiting for the startup tasks only makes sense when it will be lingering
for some time paused, so the first request is very fast. In case a
request is made while the qube has not finished preloading, skipping the
startup tasks allow faster marking of preloaded disposable as used.

For: QubesOS/qubes-issues#10230
For: QubesOS/qubes-issues#1512

Author: ben-grande

qubes/vm/dispvm.py

@@ -291,6 +291,7 @@ def __init__(self, app, xml, *args, **kwargs) -> None:
         self.volume_config = copy.deepcopy(self.default_volume_config)
         template = kwargs.get("template", None)
         self.preload_complete = asyncio.Event()
+        self.preload_requested_event = asyncio.Event()
 
         if xml is None:
             assert template is not None
@@ -394,11 +395,13 @@ def preload_requested(self) -> bool:
     @preload_requested.setter
     def preload_requested(self, value) -> None:
         self._preload_requested = value
+        self.preload_requested_event.set()
         self.fire_event("property-reset:is_preload", name="is_preload")
 
     @preload_requested.deleter
     def preload_requested(self) -> None:
         del self._preload_requested
+        self.preload_requested_event.clear()
         self.fire_event("property-reset:is_preload", name="is_preload")
 
     @qubes.stateless_property
@@ -484,30 +487,49 @@ async def on_domain_started_dispvm(
         """
         if not self.is_preload:
             return
-        timeout = self.qrexec_timeout
-        # https://github.com/QubesOS/qubes-issues/issues/9964
-        path = "/run/qubes-rpc:/usr/local/etc/qubes-rpc:/etc/qubes-rpc"
-        rpcs = ["qubes.WaitForRunningSystem"]
-        if self.features.check_with_template(
-            "supported-feature.late-gui-daemon", False
-        ):
-            rpcs.append("qubes.WaitForSession")
-        try:
-            async with asyncio.TaskGroup() as task_group:
-                for rpc in rpcs:
-                    service = '$(PATH="' + path + '" command -v ' + rpc + ")"
-                    task_group.create_task(
+        if not self.preload_requested:
+            timeout = self.qrexec_timeout
+            # https://github.com/QubesOS/qubes-issues/issues/9964
+            path = "/run/qubes-rpc:/usr/local/etc/qubes-rpc:/etc/qubes-rpc"
+            rpcs = ["qubes.WaitForRunningSystem"]
+            if self.features.check_with_template(
+                "supported-feature.late-gui-daemon", False
+            ):
+                rpcs.append("qubes.WaitForSession")
+            start_tasks = []
+            for rpc in rpcs:
+                service = '$(PATH="' + path + '" command -v ' + rpc + ")"
+                start_tasks.append(
+                    asyncio.create_task(
                         self.wait_operational_preload(rpc, service, timeout)
                     )
-        except ExceptionGroup as e:
-            # Show detailed exception in desktop notification.
-            wanted_ex_group, _ = e.split(qubes.exc.QubesException)
-            if wanted_ex_group:
-                messages = [
-                    "\n" + str(exc) for exc in wanted_ex_group.exceptions
-                ]
-                raise qubes.exc.QubesException("\n".join(messages))
-            raise
+                )
+            break_task = asyncio.create_task(
+                self.preload_requested_event.wait()
+            )
+            tasks = [break_task] + start_tasks
+            try:
+                async for earliest_task in asyncio.as_completed(tasks):
+                    await earliest_task
+                    if earliest_task == break_task:
+                        for incomplete_task in [
+                            t for t in start_tasks if not t.done()
+                        ]:
+                            incomplete_task.cancel()
+                    else:
+                        if all(t.done() for t in start_tasks):
+                            break_task.cancel()
+            except asyncio.CancelledError:
+                pass
+            except ExceptionGroup as e:
+                # Show detailed exception in desktop notification.
+                wanted_ex_group, _ = e.split(qubes.exc.QubesException)
+                if wanted_ex_group:
+                    messages = [
+                        "\n" + str(exc) for exc in wanted_ex_group.exceptions
+                    ]
+                    raise qubes.exc.QubesException("\n".join(messages))
+                raise
         if not self.preload_requested:
             await self.pause()
         self.log.info("Preloading finished")
@@ -722,7 +744,7 @@ async def from_appvm(
                     [dispvm.name], reason="qube was requested"
                 )
                 dispvm.preload_requested = True
-                timeout = int(dispvm.qrexec_timeout * 1.2)
+                timeout = getattr(dispvm, "qrexec_timeout", 60)
                 try:
                     if not dispvm.features.get(
                         "preload-dispvm-completed", False